Re: lambda, ->, haskell, and so on

Hi --

On Thu, 1 May 2008, Brian Mitchell wrote:

> On Wed, Apr 30, 2008 at 11:26 PM, Dave Thomas <[e-mail]> wrote:
>> This is one of those e-mails that I know from the start to be futile, bu=
t...
>>
>>  For a while now, the
>>
>>      -> (params) { block }
>>
>>  syntax in Ruby 1.9 has bothered me, but I've never been sure why. Today=
,
>> while playing with pure, it struck me. The '->' sequence is in an unexpe=
cted
>> place. Having played with some functional languages, I'm used to lambdas
>> being written
>>
>>   \ params -> block
>>
>>  That is, the lambda is introduced with a \ (because, presumably, it loo=
ks a
>> bit like =CE=BB). The -> sequence separates the parameters from the bloc=
k. This
>> had become ingrained into be, in the same way that the equals sign in an
>> assignment
>>
>>   a =3D expression
>>
>>  goes between the lvalue and the rvalue.
>>
>>  So, when I come to Ruby 1.9, suddenly there's some dissonance between w=
hat
>> I was used to and what I now have to type. The -> comes before the
>> parameters, not after. It's as if I had to write assignments
>>
>>   =3D a expression
>>
>>  So, here's the futile part... :)
>>
>>  Is it too late for Ruby 1.9 to support lambdas that look like
>>
>>   \ p1, p1 -> { block }
>>
>>  I honestly feel this would be more natural, and more in line with the
>> prevailing idioms. I suspect it's parsable if you make the simplifying
>> assumption that line continuations must only have whitespace after them.
>
> I remember having a slight issue with the syntax as well when it was
> announced. I remember the round table at the 2005 RubyConf in San
> Diego where we discussed a number of alternatives.
>
> One idea I had proposed was to allow arguments to work within the
> block like they do now but with -> (more examples below).  I believe
> it was shot down as being to odd (but look where we are now).
>
> foo { |a, b|  a + b }
> foo { a, b -> a + b }
>
> and thus:
>
> lambda { a, b =3D 3 -> a + b }
>
> ... solving the original problem of argument list syntax.  If we also
> wanted a lighter weight notation we could make {->} result in a proc
> object rather than act as a block parameter.  Or if you like unicode:
>
> =CE=BB { x -> 42 }
>
>
> (Finally, there might be a way to allow syntax w/o {} or do-end but
> I'm not sure how far we should push -- "lambda x -> 42" looks rather
> nice though)

All I can say is: any of these are preferable, in my opinion, to
->(){}. The -> does not look like a lambda character (apologies to
Matz, but it simply doesn't); it looks like an arrow, point from
nothing to something, and I find it pretty jarring.

@Dave: you once suggested something like this (I think in San Diego):

   def (a,b,c)
     # code
   end

as a way to create an anonymous function that used method argument
semantics (which I think is what the whole -> thing is about). There
was applause and cheering from the room. I'm not sure what happened to
that idea.


David

--=20
Rails training from David A. Black and Ruby Power and Light:
   INTRO TO RAILS         June 9-12            Berlin
   ADVANCING WITH RAILS   June 16-19           Berlin
   INTRO TO RAILS         June 24-27           London (Skills Matter)
See http://www.rubypal.com for details and updates!