Ruby: A function returning another function - ruby

Question

In order to understand the functional programming part of ruby I want to write a function that takes 2 functions f(x,y),g(x) as arguments and returns a new function h(x,y)=f(g(x),g(y)).
def foo(x, y)
return x+y
end
def bar(x)
return 2*x
end
def comp(f,g)
end
f=comp(f,g)
f(1,2) #=> 6
I tried things like
def comp(f,g)
mylambda = lambda {|x,y| return f(g(x),g(y))}
return mylambda
end
f=comp(foo, bar)
f.call(1,2)
I thought f would be a Proc now, and I could just call it. But apparently "in `foo': wrong number of arguments (0 for 2) (ArgumentError)"
What syntax would I have to use? And is it possible to return a "real" function instead of a Proc, so that instead of f.call(1,2) I could just writhe f(1,2) like if I had just defined f myself normaly?

Answer 1

This type of functional pattern doesn't work as smoothly as on more functional languages, as javascript or python. Since ruby has optional parentheses, writing foo is the same as calling the foo method without passing any arguments.
To get a reference to a method, you need to use the Object#method method:
def foo(x, y)
x + y
end
def bar(x)
x * 2
end
def comp(f, g)
lambda { |x, y| f.call(g.call(x), g.call(y)) }
end
h = comp(method(:foo), method(:bar))
h.call(1, 2) # => 6

Answer 2

Ruby doesn't have first class functions like Python. Ruby has lambdas, and method objects that can be constructed specially from a method, but methods themselves are not objects. The closest you'll get to this is this:
def foo(x, y)
return x+y
end
def bar(x)
return 2*x
end
def comp(f,g)
return lambda {|x, y| f.call(g.call(x), g.call(y))}
end
f=comp(method(:f),method(:g))
f.call(1,2) #=> 6
Also, for the calling syntax point, you can call a lambda with square brackets, so you could do this:
f[1,2]

Answer 3

What you have there aren't functions, they are methods. Functions (more precisely: procedures) are defined like this:
foo = -> (x, y) { x + y }
bar = -> x { 2 * x }
comp = -> (f, g) { -> (x, y) { f.(g.(x), g.(y)) } }
f = comp.(foo, bar)
f.(1, 2) #=> 6

Answer 4

Try this:
def foo() lambda {|x,y| x+y} end
def bar() lambda {|x| 2*x} end
def comp(f,g) lambda {|x,y| f[g[x], g[y]]} end
h = comp(foo, bar)
h[1,2] # => 6
or any of the following
h.call(1,2) # => 6
h.(1,2) # => 6
h.yield(1,2) # => 6
If you'd prefer,
foo = lambda {|x,y| x+y}
bar = lambda {|x| 2*x}
Before this question I was unaware of the myriad of ways one can now invoke a lambda (or proc). (The rationale for providing Proc#yield escapes me, as it is the same as call and may be confused with the unrelated yield keyword we all know and love.) One could substitute Proc.new or proc for lambda, or create the lambda with the "stabby" syntax -> (e.g., def bar() ->(x) {2*x} end.

Answer 5

f=comp(foo, bar)
This won't work like it would in python. The error message you're getting is wanting to see something like this.
f = comp(foo(1,2), bar(1))
You need to actually make foo and bar lambdas themselves (or methods that return lambdas) if you want to call it like that:
foo = lambda { |x, y| x + y }
bar = lambda { |x| 2 * x }
or
def foo(x, y)
lambda { |x, y| x + y}
end
def bar(x)
lambda { |x| 2 * x }
end
Then you can achieve what you want to do.