Issue #12957 has been updated by Dominic Sisneros.


I want this too

MyLambda = Class.new Proc

I want MyLambda{|x| x + 1}.lambda? to == true 

I only want it when initializing the new lambdas.  I want easy initialization with a block

Maybe allow Proc.new to accept true or false

class Proc

  def initialize(lmbda = false, &block)
       if lmbda
         __lambda__ = true
       end
       block = block
  end

end

then 

class MyLambda
    def initialize(&block)
       super(true,&block)
    end
end

MyLambda.new{|x| x + 1}.lambda? == true
    

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

* Author: Colin Fulton
* Status: Open
* 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>