How does this recursive functional permutation generator work? - ruby

Question

This code is written in a functional programming style.
Below is how this should work.
(permutations ‘(a b c)) --> ((a b c) (a c b) (b a c) (b c a) (c a b) (c b a))
Please explain how fold and map work in this code and also recursive permutation...
def map(f, lst)
lst.map{|v| f.call(v)}
end
def fold(f, init, lst)
lst.reduce(init){|w, a| f.call(w, a)}
end
def permutations(lst)
lst.empty? ? [[]] : fold(lambda{|w, a| w + a}, [], map(lambda{|v| map(lambda{|p| [v]+p}, permutations(lst-[v]))}, lst))
end

Answer 1

Let me give this a shot.
def map(f, lst)
lst.map{|v| f.call(v)}
end
map takes an array lst and applies a function f on each element of lst.
The following example doubles each element of an array.
irb(main):007:0> map(lambda {|i| i * 2}, [1,2,3])
=> [2, 4, 6]
Next,
def fold(f, init, lst)
lst.reduce(init){|w, a| f.call(w, a)}
end
fold takes an array lst, an initial value init, applies function f on each element of lst and combines it with the previous result to return a value. The result of f.call(w, a) is stored in w. w has an initial value of init.
In plain ruby,
w = init
lst.each do |a|
w = f.call(w, a)
end
return w
In the following example, fold takes the sum of the array by adding each element.
irb(main):010:0> fold(lambda {|a, i| a + i}, 0, [1,2,3])
=> 6
Now, the main function,
def permutations(lst)
lst.empty? ? [[]] : fold(lambda{|w, a| w + a}, [], map(lambda{|v| map(lambda{|p| [v]+p}, permutations(lst-[v]))}, lst))
end
The first part is easy. If lst is empty, return [[]].
The second part is
fold(lambda{|w, a| w + a}, [], map(lambda{|v| map(lambda{|p| [v]+p}, permutations(lst-[v]))}, lst))
We'll work backwards from the innermost.
map(lambda{|p| [v]+p}, permutations(lst-[v]))
This is simple. For each element returned by permutations, we append [v] (v is defined in the outer map). permutations takes the array minus the element v.
Here's one example.
irb(main):012:0> permutations([1,2,3]-[3])
=> [[1, 2], [2, 1]]
irb(main):013:0> map(lambda{|p| [3]+p}, permutations([1,2,3] - [3]))
=> [[3, 1, 2], [3, 2, 1]]
Next we go one step higher where we see that the v in the inner map is each element from lst.
map(lambda{|v| map( ... )}, lst)
In plain ruby, this is basically
lst.map do |v|
a = permutations(lst - [v])
a.map {|p| [v] + p}
end
Finally, we have
fold(lambda{|w, a| w + a}, [], map( ... ))
For each element in the array returned by map, we add it to w which is initially an empty array [].
irb(main):019:0> fold(lambda {|w, a| w + a}, [], [[[1, 2]], [[2, 1]]])
=> [[1, 2], [2, 1]]
If you want to know why this algorithm works, consider the patterns.
irb(main):021:0> permutations([1,2,3])
=> [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
which is same as
irb(main):023:0> permutations([1,2]).map {|i| i + [3]}
=> [[1, 2, 3], [2, 1, 3]]
irb(main):024:0> permutations([1,3]).map {|i| i + [2]}
=> [[1, 3, 2], [3, 1, 2]]
irb(main):025:0> permutations([2,3]).map {|i| i + [1]}
=> [[2, 3, 1], [3, 2, 1]]

Answer 2

Please explain how fold and map work in this code
Those are simply message sends (in other languages they are called method calls). They are calling the methods named fold and map, respectively.
and also recursive permutation...
The permutation method uses the methods named fold and map. There is no definition for those methods, so this will simply raise a NoMethodError.