New lambda syntax in Ruby 1.9

I'm slowly getting used to the new -> way of specifying lambdas in Ruby 1.9. I still feel that, as a notation, it could be clearer. (I'd personally like just plain backslash, because that looks pretty close to a real lambda character, but that's not going to happen.) But having punctuation, rather than the word lambda, makes a surprising difference to the way my eyes read code.

For example, you could write a method that acts like a while loop.

def my_while(cond, &body)
  while cond.call
    body.call
  end
end   

In Ruby 1.8  and 1.9, you could call this as

a = 0
my_while lambda { a < 5 } do
   puts a
   a += 1
end

But my brain finds that seriously hard to scan. The Ruby 1.9 -> syntax makes it slightly (just slightly, mind you) better:

a = 0
my_while  -> { a < 5 }  do
   puts a
   a += 1
end

I suspect this is just a question of time. In a year or so, we'll parse the -> syntax in our heads without thinking twice. Once it does become natural, I suspect we'll find all sorts of new uses for procs.

Comments

[Joc]

I agree about the readability but don't think -> is much of an improvement. For one thing it looks like it's pointing the wrong way.

What about just having:

my_while { a < 5 } do
..
end

Just a guess, but couldn't the compiler attempt to treat the contents of the {} as a lambda if it throws "odd number list for Hash" ?

I realise this might cause confusion if you misformat a Hash by accident though.

Or how about

my_while ^{ a < 5 }

which is also similar to the lambda symbol?

[Bucciarati]

What about using λ ?

[Dan Yoder]

I don't know. Our Waves web app framework has tried to embrace Ruby's inner lambda, but I don't see this notation helping at all. The arrow suggests some sort of mapping is happening. It is doubly confusing if you use lambdas as values in hashes.

:foo => -> { ... }

Ugh. I think lambda, while obviously a bit more verbose is worth the extra 4 characters. Also, as the above reader suggested, why not really embrace unicode and allow the actual λ character? Especially since the lambda keyword already provides a clear fallback? Ah, well.

[Dave Thomas]

The new syntax lets you do stuff you can't do with lambda:

pr = -> (a, b=1, &c) { ... }

Dave

[Lawrence Pit]

Makes you wonder why this syntax couldn't be used instead:

pr = lambda {|a, b=1, &c| ... }

which would be the logical extension of what we already know.

But apparently ruby's parser can't handle that. They say. Therefor it had to become:

pr = lambda(a, b=1, &c) { ... }

but the parser couldn't handle that either, and therefor they needed a different syntax for lamdba:

pr = -> a, b=1, &c { ... }

I like the new syntax better, except I think -> should be replaced with something else.

[ste]

@Dan: the new syntax for symbol keys in literal hashes makes things a little less "ugh":

hash = { foo: ->(a,b){ a + b } }

What about making "lambda" a keyword and using that instead of "->"?

[Simon B.]

Reasons not to make "lamda" a reserved keyword might include playing nice to code that might already use "lamda" for other purposes. And keeping the keyword count low is good and one important first impression ruby made at me.

Having read
http://pragdave.blogs.pragprog.com/pragdave/2008/04/fun-with-ruby-1.html

and
http://www.oreillynet.com/ruby/blog/2008/05/is_qwerty_harming_language_des.html

I say it's time to try. Mapping in a λ on the keyboard couldn't be too difficult? Non-us keyboards have a key with §½ where US-ones have `.
And let's make unicode (UTF-8, unix style - without the unneeded start bytes) the standard encoding for .rb, and everything else.

One way forward could be to get some japanese coders contribute to your source code. Their names in the file header comments are very likely to make text-editors autodetect UTF-8.

[markus]

I dont know.... I dont really like the ->

I feel it visually distorts the whole code for no apparently needed reason.

λ on the other hand would be a fun character.

Anyway as long as I dont have to use that ugly -> i dont care.

[Rob Grainger]

FWIW, I find that it's easier to cope with the use of -> for lambda expressions if you imagine it being rotated 45 degrees CCW - yielding a (nearly) passable imitation of a λ. ;)

(OK it's not perfect)

[Rob Grainger]

FWIW, I find that it's easier to cope with the use of -> for lambda expressions if you imagine it being rotated 45 degrees CCW - yielding a (nearly) passable imitation of a λ. ;)

(OK it's not perfect)

[Rob Ortiz]

If you want to pass your closure as a option to a hash you get something that looks like this:

method_call(:foo => -> { puts 'ruby is not Erlang!!!'})

this is a much easier read in 1.8

method_call(:foo => lambda { puts 'ruby is not Erlang!!!'})

so why not just include both and end all the fuss ....