Different approaches to binary methods: double-dispatch, pattern matching and multimethods

I've chosen a simple problem that can be solved using binary operations to show some different approaches to them: the Rock, Paper and Scissors game

Binary methods in OOP.
This is a Ruby code that is using the double-dispatch pattern to solve this problem following a "full" OOP approach (not using any conditionals on types):

	class RockPaperScissors
	def hand(g1, g2)
	g1.play_against(g2)
	end
	end
	class Rock
	def play_against(other)
	other.play_against_rock(self)
	end
	def play_against_scissors(aScissors)
	Lose.new(aScissors, self)
	end
	def play_against_rock(aRock)
	Tie.new(self)
	end
	def play_against_paper(aPaper)
	Win.new(aPaper, self)
	end
	def to_s
	"Rock"
	end
	end
	class Paper
	def play_against(other)
	other.play_against_paper(self)
	end
	def play_against_scissors(aScissors)
	Win.new(aScissors, self)
	end
	def play_against_rock(aRock)
	Lose.new(aRock, self)
	end
	def play_against_paper(aPaper)
	Tie.new(self)
	end
	def to_s
	"Paper"
	end
	end
	class Scissors
	def play_against(other)
	other.play_against_scissors(self)
	end
	def play_against_rock(aRock)
	Win.new(aRock, self)
	end
	def play_against_paper(aPaper)
	Lose.new(aPaper, self)
	end
	def play_against_scissors(aScissors)
	Tie.new(self)
	end
	def to_s
	"Scissors"
	end
	end
	class Win
	def initialize(g1, g2)
	@g1 = g1
	@g2 = g2
	end
	def to_s
	"First player's " + @g1.to_s + " beats second player's " + @g2.to_s
	end
	end
	class Lose
	def initialize(g1, g2)
	@g1 = g1
	@g2 = g2
	end
	def to_s
	"Second player's " + @g2.to_s + " beats first player's " + @g1.to_s
	end
	end
	class Tie
	def initialize(g)
	@g = g
	end
	def to_s
	"Two players with " + @g.to_s + ", the game is tied"
	end
	end

view raw RockPaperScissotsRuby.rb hosted with ❤ by GitHub

When you call hand with two variants of Gesture (Rock, Paper and Scissors are all variants/types of Gesture but since Ruby has duck typing we don't need to have this superclass), it sends the message play_against to the first variant. That's the first dispatch.

Rock, Paper and Scissors have its own version of play_against and the first dispatch sends, according to the type of the message receiver, the execution to one of them. It uses polymorphism on the receiver to get to the right method.

Once in there, instead of falling in the temptation of using a conditional depending on types, we use polymorphism again but this time on the object passed as a parameter.

For instance, if we call hand(Rock.new, Paper.new) the first dispatch will send us to the play_against method of Rock. If you've got there, you know that the first player's gesture is a Rock, so we keep that information in the name of a new method, play_against_rock and use polymorphism again sending that message to the second object. This is the second dispatch that, in this case, will send us to the play_against_rock method of Paper where we can return that a Rock is beaten by a Paper: Lose.new(aRock, self).

For three variants there are nine possible combinations (3 x 3), which originates 9 functions: a version of play_against_rock, play_against_paper and play_against_scissors for each variant.
You might imagine how complicated would be implementing n-ary methods.

You can check the whole example with its tests in Rock, Paper, Scissors game using double dispatch in Ruby.

Binary methods with functional decomposition
In functional decomposition all the cases are considered in the same function: hand.

	type gesture =
	| Paper
	| Rock
	| Scissors
	type result =
	| Win of gesture * gesture
	| Lose of gesture * gesture
	| Tie of gesture
	let hand g1 g2 =
	match g1 with
	| Paper ->
	(match g2 with
	| Rock -> Win(g1, g2)
	| Paper -> Tie g1
	| Scissors -> Lose(g1, g2))
	| Rock ->
	(match g2 with
	| Rock -> Tie g1
	| Paper -> Lose(g1, g2)
	| Scissors -> Win(g1, g2))
	| Scissors ->
	(match g2 with
	| Rock -> Lose(g1, g2)
	| Paper -> Win(g1, g2)
	| Scissors -> Tie g1)
	let gesture_to_string g =
	match g with
	| Paper -> "Paper"
	| Rock -> "Rock"
	| Scissors -> "Scissors"
	let result_to_string res =
	match res with
	| Win (g1, g2) -> ("First player's " ^ gesture_to_string g1 ^ " beats second player's " ^ gesture_to_string g2)
	| Lose (g1, g2) -> ("Second player's " ^ gesture_to_string g2 ^ " beats first player's " ^ gesture_to_string g1)
	| Tie g -> ("Two " ^ gesture_to_string g ^ "s, the game is tied")

view raw RockPaperScissorsGame.ml hosted with ❤ by GitHub

In hand we first use pattern matching on the first variant and then pattern matching again on the second. In this code, I nested the second pattern matching but I could have used helper functions called play_against_rock, play_against_paper and play_against_scissors to make it more similar to the OOP version.

As you see there are again 9 cases, but this code is less "spread out" than the OOP one.
However it seems that implementing n-ary methods would also be very complicated using this approach.

You can check the whole example with its tests in Rock, Paper, Scissors game using pattern matching in OCaml.

Multimethods
Quoting Dan Grossman:

"Not all OOP languages require the cumbersome double-dispatch pattern to implement binary operations in a full OOP style. There are languages that support multimethods, also known as multiple dispatch that provide more intuitive solutions. Multiple dispatch is "even more dynamic dispatch" by considering the class of multiple objects and using all that information to choose what method to call."

Ruby, Java and C++ don't support multimethods. Java and C++ have static overloading by which you can have multiple methods with the same name but different types for the arguments. The difference is that the method to call is determined in this case at compilation time and not in run time. This can be convenient but does not avoid having to use double-dispatch in this example.

Clojure has multimethods:

	(ns rockpaperscissors.core)
	(derive ::Rock ::Gesture)
	(derive ::Paper ::Gesture)
	(derive ::Scissors ::Gesture)
	(defmulti hand (fn [x y] [(:Gesture x) (:Gesture y)]))
	(defmethod hand [:Rock :Paper] [_ _]
	"Second player's Paper beats first player's Rock")
	(defmethod hand [:Rock :Rock] [_ _]
	"Two players with Rock, the game is tied")
	(defmethod hand [:Rock :Scissors] [_ _]
	"First player's Rock beats second player's Scissors")
	(defmethod hand [:Paper :Rock] [_ _]
	"First player's Paper beats second player's Rock")
	(defmethod hand [:Paper :Scissors] [_ _]
	"Second player's Scissors beats first player's Paper")
	(defmethod hand [:Paper :Paper] [_ _]
	"Two players with Paper, the game is tied")
	(defmethod hand [:Scissors :Rock] [_ _]
	"Second player's Rock beats first player's Scissors")
	(defmethod hand [:Scissors :Paper] [_ _]
	"First player's Scissors beats second player's Paper")
	(defmethod hand [:Scissors :Scissors ] [_ _]
	"Two players with Scissors, the game is tied")

view raw rockpaperscissors.clj hosted with ❤ by GitHub

The treatment of the binary method is much simpler in this example than in the other two. Moreover, you can use the multimethods for n-ary methods too.

You can check the whole example with its tests in Rock, Paper, Scissors using Clojure multimethods

I had been thinking about doing this posts since I finished the great Programming Language course in Coursera.
Well, better late than never.

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

PS: According to Dan, it seems that in C# one can achieve the effect of multimethods by using the type "dynamic" in the right places.