Issue #12957 has been updated by Benoit Daloze.


Actually, it is possible to create a single block of code that can be proc or lambda with #send:

    > Kernel.send(:lambda) {}.lambda?
    => true
    > Kernel.send(:proc) {}.lambda?
    => false

I was surprised as well this worked, the Kernel#lambda method is quite magic:
https://github.com/graalvm/truffleruby/pull/12#discussion_r96889356

----------------------------------------
Feature #12957: A more OO way to create lambda Procs
https://bugs.ruby-lang.org/issues/12957#change-62659

* Author: Colin Fulton
* Status: Feedback
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
Currently to create a lambda Proc one has to use `lambda { }` or `-> { }`. For doing metaprogramming it would be nice to have a more OO way to generate them. Something like `LambdaProc.new`. That way one could write:

```ruby
class MetaThingy
  def initialize proc_class
    @anonymous_function = proc_class.new do
      # Some Code
    end
  end
end
```

and pass in either `Proc` or `LambdaProc` depending on their needs, instead of:

```ruby
class MetaThingy
  def initialize proc_type
    @anonymous_function = case proc_type
                          when :proc
                            proc do
                              # Some Code
                            end
                          when :lambda
                            lambda do
                              # Some Code
                            end
                          end
    end
  end
end
```

This is not a common use case, but would help make the language more orthogonal.



-- 
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>