The map(&method(:local_method)) or yield_self(&method(:local_method)) pattern is absolutely real

and very useful.

Everyone who suggests something tends to think of it as useful and often pretty too. :-)

I personally have become too picky perhaps. I already don't like yield_self much at all; "then"

is better than yield_self though.

In ruby it is possible to avoid a lot of things and still end up writing pretty code that is

fun.

My point was, we have plenty in our current codebase

I think a pretty syntax is great, but it is not necessarily ruby's primary design goal. It is

difficult to say because I am not matz :) but I think matz has said before that ruby should

be fun to use; and solve real problems; and help people. If you look at the safe navigation

operator, this is a good example, in my opinion. Someone had a use case and suggested a

solution to his problem, and matz agreed with the problem description and added the safe

navigation operator.

There are lots of things I myself have not yet used, including the safe navigation operator.

I also have not yet used the -> lambda variant. I no longer use @@variables either. I am

sure other people have different means how to use and approach ruby. What I do use, and

that has been somewhat newish (well not yet 10 years old I think), was the new additional

hash syntax, since it has a net benefit - less to type, e. g.:

:foo => :bar

versus

foo: :bar

Especially if I have lots of entries, the second variant is indeed easier to use for me.

And I can definitely say it brings value for code design and clarity, and will

be even more so with map(&.:local_method) syntax.

Using this reasoning we can say that EVERY addition is GOOD and USEFUL because we have

more features. But it is not quite like that. More and more features make a language

harder to use and more complicated too. Some features also look strange. For example,

I personally dislike the map(&.:local_method). I don't have an alternative suggestion

that is nice to read, but it is hard for me to visually distinguish between what is

going on there.

Ultimately it is up to matz how he wants to change ruby, but I really don't feel that

in all the discussions the trade off was or is really worth it. This may be up to

personal preferences or habits, yes - but ... I don't know.

When I look at things such as map(&.:local_method) then the original suggestion in

the issue of:

roots = [1, 4, 9].map Math->method

becomes a LOT cleaner and easier to read. ;)

(Only thing that puts me off is that -> is used in e. g. LPC to invoke methods;

I much prefer just the single "." notation. Do also note that I agree that we

should be able to pass arguments to .map(&) but ... I don't know. It's visually

not very pleasing to my eyes. :\ )