Is there a short way to write `{|x| x}`?

Question

We often shorten a block using the & notation on a symbol like this:

some_array.group_by(&:foo) 

Is there a similar way to shorten expressions like {|x| x}?

some_array.group_by{|x| x} 

If there were a method Object#self that returns self, then we can do

some_array.group_by(&:self) 

but unfortunately, there is no such method. In terms of the number of characters, it may be longer, but readability improves.

Answer 1

Yes. #itself was implemented in Ruby 2.2.0.

---

You can access the Ruby core team discussion about this feature here.

As an interesting analogue, the #ergo method has been proposed, which would yield the receiver to a given block.

If you haven't yet upgraded to Ruby 2.2.0, you may wish to backport #itself and/or define #ergo as follows:

class Object   def itself; self end   def ergo     fail ArgumentError, "Block expected!" unless block_given?     yield self   end end 

And then:

some_array.group_by &:itself 

Answer 2

Well, there's no built-in as far as I know, but you can make a reusable identity block:

id = Proc.new {|x| x} some_array.group_by(&id) 

And then if you really wish this were a language feature:

class Object   def it     Proc.new {|x| x}   end end 

And then you can do:

some_array.group_by(&it) 

wherever you like. This may void your warranty.