I think the proposal is:
def { something }

or

def do
  something
end

which would declare a lambda. I think differences between lambda and method
are quite small--small enough to justify collapsing ideas in the mind of the
programmer. Here are similarities:

   - Declared arguments are mandatory
   - return inside "method" returns from method, not the lexically enclosing
   block
   - yield inside "method" yields to block passed into method, not the
   lexically enclosing block

Differences:

   - Method has "self" belonging to its object -- lambda inherits self from
   its lexical scope.

However, this just means that lambdas are methods bound to the current
scope.

In constrast, procs are different:

   - Declared arguments are optional
   - return inside proc or block returns from the lexically enclosing block
   - yield inside proc of block yields to block passed into lexically
   enclosing block

In essence, we have two different constructs here, with four different ways
to describe them (method, lambda, proc, block). All I am suggesting is that
we collapse down the four ways to describe into the two actual constructs :)

-- Yehuda

On Sun, Aug 23, 2009 at 9:21 PM, Yukihiro Matsumoto <matz / ruby-lang.org>wrote:

> Hi,
>
> In message "Re: [ruby-core:25068] Re: Proposal: Simpler block format"
>     on Mon, 24 Aug 2009 13:03:53 +0900, brian ford <brixen / gmail.com>
> writes:
>
> |Could we add def {} and see by usage which prevails? Or take a
> |world-wide vote (perhaps weighted by number of lines of Ruby code
> |written by the voter)?
>
> The def keyword is to define a method.  I assume your def {} proposal
> is to declare an anonymous procedure object, which is NOT a method at
> all.  For me, the difference is big enough to reject the proposal.
>
>                                                        matz.
>
>


-- 
Yehuda Katz
Developer | Engine Yard
(ph) 718.877.1325