Yes, I absolutely find
customers.map(&:name)
a win over customers.map { |c| c.name }
My reasoning is that the former is less code overall, is fundamentally 'simpler' (passing a parameter to a method rather than calling with a block), and the code it replaces has redundancy (the block parameter is there only to be immediately referenced for the sole purpose of getting at one of the object's attributes). With #try, there's similarly less code overall and it removes redundancy.I agree that brevity alone is not enough to prefer one idiom over another. Expressiveness is a big part. I like these idioms, so I'm actually in the camp that they do make the code more precise and communicative.
In my book, though, #returning is simply an exception. A simple assignment and return are already so fundamentally expressive on their own, that — to me — replacing them with a method invocation and block doesn't get you more expressiveness, and instead it actually makes things less readable.
To me, it would be like writing an abstraction layer to replace the use of variables in the language, where you have to invoke a special-purpose lookup table class to set and retrieve values. Why would you prefer
Variable.set(:foo, 'bar')
puts(Variable.get(:foo))
over foo = 'bar'
puts(foo)
Why not just use variables?