Issue #13559 has been updated by Eregon (Benoit Daloze). I agree #yield_self is less than ideal. To start, it is quite long (10 letters including a underscore) for a very simple method. In an ideal world, I think #itself with a block doing what #tap does today and #tap doing what #yield_self does would make sense. But that cannot work with compatibility. This blog post also made me realize it can be confusing as a method name: https://bogdanvlviv.github.io/posts/ruby/new-method-kernel-yield_self-since-ruby-2_5_0.html > "#tap yields self to the block and then returns self." That sounds exactly to what "yield_self" would do. > "#yield_self yields self to the block and then returns the result of the block execution." #tap already "yields self" and the difference that the block value is returned is absent from the name yield_self. I am unfortunately not sure what a good name would be. Maybe #pipe ? (#| conflicts with Array#| so that's not good) number.pipe { |x| x ** 2 }.next.pipe { |x| x ** 2 } Fundamentally it works like #map on a single element, but that's already taken by Enumerable#map and we need something that does not imply collections. #as and #let seem the most descriptive but do not read well in a chain of method calls. #itself seems a good compromise. The current usage like `ary.count(&:itself)` to make a block that returns the element and then expanding it to `number.itself { |n| n*n }` makes sense to me. Instead of having `&:itself` be a simple block just returning the argument we can customize it by given #itself a block and return what we want (which is what most blocks do, use the return value of the block instead of ignoring it). ---------------------------------------- Feature #13559: Change implementation of Feature #6721 https://bugs.ruby-lang.org/issues/13559#change-64794 * Author: dunrix (Damon Unrix) * Status: Feedback * Priority: Normal * Assignee: * Target version: ---------------------------------------- Hi, please reconsider implementation of feature request #6721 planned for Ruby 2.5.0 . Instead of introducing new method `Object#yield_self`, just reuse existing `Object#itself` by taking an optional block argument. Find it much clearer and more logical solution, not superfluous polluting of API space. `Object#itself` just returns target object, optional block would return alternative value with target object passed as block argument. Prototyped sol. in Ruby: ~~~ruby class Object def itself block_given? ? yield(self) : self end end ~~~ Not aware of any case, where it would break backward compatibility. -- https://bugs.ruby-lang.org/ Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe> <http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>