Ruby

Why a new ticket? What's wrong with this one? If you wanted clarification you didn't have to close it, and even now you can still reopen.

As to the substance, if you want to transform an existing proc or lambda in a way that involves creating a new one and calling the original from it, it makes sense to end up with the same "type" you started with (proc or lambda). The simplest example is negation:

 class Proc def negate self.class.new do |*args, &block| not self.(*args, &block) end end end 

The above will turn a lambda into a proc. Why shouldn't the Proc constructor be able to create a lambda? Lambdas should have probably been a sub-type, but as long as they share the same type and hence constructor, it seems almost an obligation for it to be able to construct either: Proc.new(lambda: true)

There is Kernel.send(lambda ? :lambda : :proc) { ... } if you really really need this.
But it's probably slow and Ruby implementations have troubles to optimize this as they have no idea when parsing if the block is for a proc or lambda.

Of course the more sensible thing would be:

class Proc def negate if lambda? lambda do |*args, &block| not self.(*args, &block) end else proc do |*args, &block| not self.(*args, &block) end end end end 

That has a significant advantage that a given block only has proc or lambda semantics but not both (and so using e.g., break is possible).
And also from looking at the backtrace you can know which it was.

I don't think it matters if negate e.g. always returns a lambda in this case (the caller can only observe the difference though Proc#lambda? and that shouldn't matter), so it should just be:

class Proc def negate -> (*args, &block) do not self.(*args, &block) end end end 

As discussed extensively in related tickets, it's a very bad idea to convert from proc to lambda or vice-versa, but at least this issue only suggests a polymorphic create with a literal block.

So the important question here is why do you need to preserve whether the source Proc was a lambda or not?