Strategy pattern and higher-order functions?

As a practice, I'm implementing different design patterns in different languages.

I'm using the examples in the great Head First Design Patterns book as the basis for this implementations.

The book examples are written in Java, so I'll use other languages.

I've started with the Strategy pattern.

"The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it."

The first implementation is written in C++:

I modified the book example to make it shorter. In this case the Duck class has only one configurable behavior: quacking.

This behavior is injected through its constructor but can also be modified afterwards using a setter: changeHowToQuack.

	#ifndef DUCK_H_
	#define DUCK_H_
	class QuackBehavior;
	class Duck {
	public:
	Duck(QuackBehavior * quackBehavior);
	virtual ~Duck();
	void quack();
	void changeHowToQuack(QuackBehavior * quackBehavior);
	protected:
	QuackBehavior * howToQuack;
	};
	#endif /* DUCK_H_ */

view raw Duck.h hosted with ❤ by GitHub

	#include "Duck.h"
	#include "QuackBehavior.h"
	Duck::Duck(QuackBehavior * quackBehavior) {
	howToQuack = quackBehavior;
	}
	Duck::~Duck() {
	delete howToQuack;
	}
	void Duck::quack() {
	howToQuack->quack();
	}
	void Duck::changeHowToQuack(QuackBehavior * quackBehavior) {
	delete howToQuack;
	howToQuack = quackBehavior;
	}

view raw Duck.cpp hosted with ❤ by GitHub

Since C++ is statically typed like Java, we need to create a base type for all the different behaviors or strategies. In this case the QuackBehavior abstract class (this would work as a Java interface).

	#ifndef QUACKBEHAVIOR_H_
	#define QUACKBEHAVIOR_H_
	class QuackBehavior {
	public:
	QuackBehavior(){};
	virtual ~QuackBehavior(){};
	virtual void quack() = 0;
	};
	#endif /* QUACKBEHAVIOR_H_ */

view raw QuackBehavior.h hosted with ❤ by GitHub

The Duck class has a field, howToQuack, which is a pointer to an object that implements the QuackBehavior interface. When Duck's quack() method is called, it delegates the quacking responsibility to its howToQuack collaborator.

This is one of the implementations of QuackBehavior:

	#ifndef SQUEAK_H_
	#define SQUEAK_H_
	#include "../QuackBehavior.h"
	class Squeak : public QuackBehavior {
	public:
	Squeak();
	virtual ~Squeak();
	void quack();
	};
	#endif /* SQUEAK_H_ */

view raw Squeak.h hosted with ❤ by GitHub

	#include "Squeak.h"
	#include <iostream>
	using namespace std;
	Squeak::Squeak() {}
	Squeak::~Squeak() {}
	void Squeak::quack() {
	cout << "Squeak!" << endl;
	}

view raw Squeak.cpp hosted with ❤ by GitHub

You can find the rest of them in this Bitbucket repository: StrategyPatternExampleCpp.

This is an example of how this code can be used:

	#include "Duck.h"
	#include "QuackBehaviors/Quack.h"
	#include "QuackBehaviors/Squeak.h"
	#include "QuackBehaviors/MuteQuack.h"
	int main(int argc, const char **argv) {
	Duck duck(new Quack);
	duck.quack();
	duck.changeHowToQuack(new Squeak);
	duck.quack();
	duck.changeHowToQuack(new MuteQuack);
	duck.quack();
	return 0;
	}

view raw QuackStrategyMain.cpp hosted with ❤ by GitHub

And this would be its result:

Quack!
Squeak!
<< Silence >>

Using this pattern we've encapsulated the quacking behavior and made it possible to change how the duck quacks without changing its code just by injecting new variants of the behavior. The code respects the Open-Closed Principle for the quack behavior because it's Open to extension (by creating new types of QuackBehavior) and Closed to variation (we don't need to change the Duck class).

This way of implementing the Strategy pattern in C++ or Java has to do with two facts:

1. They are both statically typed languages. 
2. Functions are not first-class citizens in any of them.

In languages like Ruby or Python we wouldn't need to use an interface like QuackBehavior. We'd just need to make the different behaviors (Quack, Squeak and MuteQuack) have a common interface: quack().

Moreover, since functions are first-class citizens in these languages, we wouldn't even need classes for the different types of behaviors. In this case, functions would suffice, as you can see in this other example of the Strategy pattern in Ruby (much less verbose than the C++ or Java ones):

	class Duck
	def initialize(how_to_quack)
	@how_to_quack = how_to_quack
	end
	def how_to_quack=(how_to_quack)
	@how_to_quack = how_to_quack
	end
	def quack
	@how_to_quack.call
	end
	end
	just_quacking = lambda {puts "Quack!\n"}
	squeaking = lambda {puts "Squeak!\n"}
	mute_quacking = lambda {puts "<< Silence >>\n"}
	duck = Duck.new(just_quacking)
	duck.quack
	duck.how_to_quack = squeaking
	duck.quack
	duck.how_to_quack = mute_quacking
	duck.quack

view raw Duck.rb hosted with ❤ by GitHub

The Strategy pattern relies on composition. I can't avoid thinking that it's a way to compose behavior that is very similar to what you do when you're using higher-order functions in functional programming.

This last example in Racket has the same functionality as the previous two:

	(define (just-quacking)
	(printf "Quack!\n"))
	(define (squeaking)
	(printf "Squeak!\n"))
	(define (mute-quacking)
	(printf "<< Silence >>\n"))
	(define (quack how-to-quack)
	(how-to-quack))
	(quack just-quacking)
	(quack squeaking)
	(quack mute-quacking)

view raw quacking.rkt hosted with ❤ by GitHub

Even though there are no objects here, you can notice some similarities.

It's also applying the Open/Closed principle because it's injecting a behavior as a function parameter, how-to-quack, that has several variations inside a higher-order function, quack, in order to change the function behavior without having to change its code. To get a new behavior, you just need to create a new type of quack function (a different quack behavior) and pass it to quack as a parameter.

Well I hope this makes you see the Strategy pattern from a little bit different perspective.

---------------------

PS: If you're interested in JavaScript, check this implementation of the Strategy pattern by Tomás Corral.

---------------------

Update:
A functional JavaScript version (very similar to Racket's one):

	var justQuacking = function() {
	console.log("Quack!");
	},
	squeaking = function() {
	console.log("Squeak!");
	},
	muteQuacking = function() {
	console.log("<< Silence >>");
	},
	quack = function(howToQuack) {
	howToQuack();
	};
	quack(justQuacking);
	quack(squeaking);
	quack(muteQuacking);
	quack(function() {
	console.log("Quack!Quack!Quack!Quack!Quack!Quack!");
	});

view raw quack.js hosted with ❤ by GitHub