folding and currying with Ruby - ruby

Question

I'm exploring Functional Programming with the Ruby language. Below is my version of a Fold in Ruby. I've tested it on a variety of functions, reverse, filter, map etc, and it returns the results as expected. But it mutates data and needs assignment statements. Can anyone help me to do the same but without violating the Functional paradigm? Can anyone help me with the partial application of the curried function at the bottom? I suspect there something obvious I'm missing. Thanks.
fold_l = lambda do |ray, base, funcky|
if ray == []
base
else
base = funcky.call(base,ray.first)
ray.shift
fold_l.call(ray,base,funcky)
end
end
abc = [1, 2, 3, 4, 5, 6, 7]
mapper = lambda {|sum, x| sum << x*x}
lengthy = lambda {|sum, _| sum + 1}
p fold_l.call(abc,[],mapper) ## works fine
p abc ## but mutates data!!
abc = [1, 2, 3, 4, 5, 6, 7]
p curryFold = fold_l.curry.(abc).(0).(lengthy) ## works fine
lengthC = curryFold.(base:0).(funcky:lengthy)
p lengthC.call.(abc) ## but this gives error

Answer 1

Rework your fold_l function to not mangle the arguments its given:
def fold_l(ray, base, funcky)
return base if ray.empty?
base = funcky.call(base,ray.first)
fold_l(ray.last(ray.length-1),base,funcky)
end
This uses last to return a copy of the arguments minus the first. It's also not necessary to use lambda here as you want a named function, so you may as well declare it formally. lambda is reserved for situations where you don't necessarily have a name for it.
Note that in Ruby it's generally rude to damage the arguments your method's given unless there's an understanding that it's acceptable. Most methods make copies if they need to perform alterations.

Answer 2

I would probably implement foldl like this – and always be careful when using recursion in languages that don't support tail call optimisation (read more)
foldl = -> (f, acc, (x,*xs)) do
if x.nil? then
acc
else
foldl.call f, (f.call acc, x), xs
end
end
add = -> (x,y) do
x + y
end
length =
foldl.curry
. (-> (acc,_) { acc + 1 })
. (0)
data = [ 1, 2, 3, 4, 5 ]
p foldl.call add, 0, data
# => 15
p length.call data
# => 5
as per #tadman's recommendation, using a normal def/end block is probably better but that's just a matter of preference – note that currying is no longer necessary with this style
def foldl f, acc, (x,*xs)
if x.nil? then
acc
else
foldl f, (f.call acc, x), xs
end
end
def add x, y
x + y
end
def length xs
foldl (-> (acc,_) { acc + 1 }), 0, xs
end
data = [ 1, 2, 3, 4, 5 ]
p foldl method(:add), 0, data
# => 15
p length data
# => 5