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

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

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

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)

> 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.

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

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

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

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

very true :)

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