[catscratch]

This doesn't make me want to use JS. The power of JS is in two things, it's in every major browser and it doesn't completely suck. JS syntax kind of sucks. The power in JS is that it's dynamic and lets you send functions around, but defining functions is much uglier than defining a lambda in Ruby:

-> {anything goes here}

or

->(a,b,c) {anything goes here}

The problem with Ruby is that you then have to .() the lambda vs. (), so that is more verbose than just calling the function.

If browsers were to embrace a language that was more Ruby-like and less clunky than JS, I'm sure I'd use it more.

[dcwca]

Ruby suffers from a confusing set of overlapping features in Procs, Blocks and Lambdas. JavaScript's function passing is a lot less opaque.

[zuck9]

ES6 lets you define functions like a => a * 2

Or (a, b, c) => a * b ^ c

[catscratch]

That's succinct, but less clear than the Ruby version, imo, as you don't have any scope indicators required for the function body.

JS:

  let f = (a,b,c) => a * b ^ c;
  f(2,3,4);

vs. Ruby:

  f = ->(a,b,c) { a * b ^ c }
  f.(2,3,4)

Ruby's shorter and clearer. But, when you use the Ruby lambda more than once in the code, you lose the brevity advantage, because of the "extra" dot. But, in Ruby I use methods more than lambdas, which would be:

  def f(a,b,c) { a * b ^ c }
  f(2,3,4)

[notyourwork]

> Ruby's shorter and clearer.

I would say the different is negligible here and claiming one is more clear than the other is purely preferential. Coming from a JS background the JS is more clear but not substantially enough for me to claim it is outright more clear a language syntax. Someone coming from a ruby background may argue the other direction.

Some languages are quite different but you are splitting hairs here and trying to be conclusive about it.

[qaq]

None is preventing you from writing let f = (a,b,c) => {a * b ^ c}; in JS

[1000hz]

when you include curly braces in arrow functions you lose the implicit return, so this function would return undefined

[johnhenry]

You can get the implicit return if you use parentheses instead:

f = (a,b,c) => (a * b ^ c)

[qaq]

very true :)

[8note]

the ruby versions isnt shorter though; you just included things you dont need: semi colons and 'let'