From: waiting_for_dev <noreply@...>
Date: 2022-03-18T05:48:53+00:00
Subject: [ruby-core:107968] [Ruby master Feature#18644] Coerce anything callable to a Proc

Issue #18644 has been reported by waiting_for_dev (Marc Busqu��).

----------------------------------------
Feature #18644: Coerce anything callable to a Proc
https://bugs.ruby-lang.org/issues/18644

* Author: waiting_for_dev (Marc Busqu��)
* Status: Open
* Priority: Normal
----------------------------------------
Functional objects are increasingly popular in Ruby. Having objects that respond to `#call` makes them interchangeable with a `Proc`.

However, when you need to perform some Proc-specific operation, like currying, you have to break the abstraction and ask for the type of object. Example:

```ruby
(callable.is_a?(Proc) ? callable : callable.method(:call)).curry[value]
```

Because of https://bugs.ruby-lang.org/issues/18620, it's not possible to make them polymorphic by taking the `:call` method:

```ruby
callable.method(:call).curry[value] # won't work!
```

Consequently, I propose building a built-in Ruby way to coerce anything callable to a proc (examples in Ruby):

### Option 1: `Object#to_proc`

```ruby
class Object
  def to_proc
    return method(:call).to_proc if respond_to?(:call)
  
    raise "Needs to respond to :call"
  end
end

class Proc
  def to_proc
    self
  end
end

callable.to_proc.curry[value]
```

### Option 2. `Kernel.Proc`

```ruby
class Kernel
  def Proc(value)
    if value.is_a?(::Proc)
      value
    elsif value.respond_to?(:call)
      value.method(:call).to_proc
    else
      raise "Needs to implement :call"
  end
end

Proc(callable).curry[value]
```



-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>