Implement Proc#* and Method#* for Proc and Method composition

[mudge]

c.f. https://bugs.ruby-lang.org/issues/6284

Allow Procs and Methods to be composed together with *.

f = proc { |x| x * 2 }
g = proc { |x, y| x + y }
h = f * g

h.call(1, 2) #=> 6

Support composition with any object that has a call method, e.g.

class Foo
  def call(x, y)
    x + y
  end
end

f = proc { |x| x * 2 }
g = f * Foo.new

g.call(1, 2) #=> 6

This implementation should be largely equivalent to the following Ruby (excepting that the lambda? property is preserved):

class Proc
  def *(g)
    proc { |*args, &blk| call(g.call(*args, &blk)) }
  end
end

[mudge]

If we could change this to send call to g with the given arguments (e.g. via rb_funcall), this would work with any object with a call method (including other Procs, Methods and regular Ruby classes).

Alternatively, we could ensure g is a Proc by calling to_proc on it if it is not already a Proc (not entirely dissimilar to using the existing StringValue macro).

As discussed on the issue tracker, this would mean the difference between the following Ruby pseudocode:

# Where g must only implement call
class Proc
  def *(g)
    proc { |*args, &blk| call(g.call(*args, &blk)) }
  end
end

vs

# Where g must only implement to_proc
class Proc
  def *(g)
    proc { |*args, &blk| call(g.to_proc.call(*args, &blk)) }
  end
end

[tsujigiri]

I, for one, would love to see this merged! :)

[marshall-lee]

I like the idea of functional composition but I don't like the implementation here.

First of all, I don't like naming it *. Any special reason why use a star symbol? For example dry-pipeline gem implements a pipeline operator >>. Of course, both operators have their numeric analogues (multiplication and bitwise right shift accordingly) and it's confusing but >> is used less often so it's a better option IMO.

And the second problem that it does not deal well with custom callable objects. I mean:

module Increment
  def self.call(x)
    x + 1
  end
end

multiply_two = proc { |x| x * 2 }

(multiply_two * Increment).call(1) # => 4
(Increment * multiply_two).call(1) # => NoMethodError

So, I like the concept of mixin with composition operator more like it's done in dry-pipeline gem. Something llike:

module Increment
  extend PipelineOperator
  def self.call(x)
    x + 1
  end
end

[mooreniemi]

FWIW I am pro *, and used it in my C extension. I'd argue it has some mindshare from: https://www.youtube.com/watch?v=seVSlKazsNk

[k0kubun]

It seems to have a conflict now. Could you rebase this from master?

[mudge]

Hi @k0kubun,

I believe this was merged by @nobu back in November 2018 in the following commits and is part of Ruby 2.6:

• a43e967
• 4eaf22c
• 3b7b706
• c71cc2d

Please feel free to close the PR.

[k0kubun]

Oh, I see. Thank you 👍