Ruby

Feature #18644

Updated by waiting_for_dev (Marc Busqué) over 3 years ago

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 adding 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` `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 
 end 

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

Back