< :前の番号
^ :番号順リスト
> :次の番号
P :前の記事(スレッド移動)
N :次の記事(スレッド移動)
|<:前のスレッド
>|:次のスレッド
^ :返事先
_:自分への返事
>:同じ返事先を持つ記事(前)
<:同じ返事先を持つ記事(後)
---:分割してスレッド表示、再表示
| :分割して(縦)スレッド表示、再表示
~ :スレッドのフレーム消去
.:インデックス
..:インデックスのインデックス
Issue #9076 has been updated by shevegen (markus heiler).
I dislike the amount of special meanings that would get associated with & and I already think that & is used too much.
Every new syntax increases the complexity of the language. Rather than extend on &, I'd rather remove the meaning of & in regards to call to_proc anyway - how great it would be if we could remove & altogether from ruby!
I will also tell you what happens once that syntax is in place:
People will come to IRC and ask what the difference is between &:to_s and &.to_s, just as they currently do all the time when they ask "what is the difference between a symbol and a string?"
----------------------------------------
Feature #9076: New one-argument block syntax: &.
https://bugs.ruby-lang.org/issues/9076#change-42741
Author: asterite (Ary Borenszweig)
Status: Open
Priority: Normal
Assignee:
Category: core
Target version: current: 2.1.0
Hello,
I'd like to introduce a new syntax for blocks that have one argument.
Currently you can do this:
[1, 2, 3].map &:to_s
With the proposed syntax this will be written as:
[1, 2, 3].map &.to_s
Instead of ":" we use a ".".
The idea is that this new syntax is just syntax sugar that is expanded by the parser to this:
[1, 2, 3].map { |arg| arg.to_s }
This new syntax allows passing arguments:
[1, 2, 3, 4].map &.to_s(2) #=> ["1", "10", "11", "100"]
It also allows chaining calls:
[1, 10, 100].map &.to_s.length #=> [1, 2, 3]
You can also use another block:
[[1, -2], [-3, -4]].map &.map &.abs #=> [[1, 2], [3, 4]]
Pros:
- Doesn't conflict with any existing syntax, because that now gives a syntax error, so it is available.
- Allows passing arguments and chaining calls
- It's *fast*: it's just syntax sugar. The "&:to_s" is slower because the to_proc method is invoked, you have a cache of procs, etc.
- It looks ok (in my opinion) and allows very nice functional code (like the last example).
Cons:
- Only supports one (implicit) argument. But this is the same limitation of "&:to_s". If you want more than one argument, use the traditional block syntax.
- It's a new syntax, so users need to learn it. But to defend this point, users right now need to understand the &:to_s syntax, which is hard to explain (this calls the "to_proc" method of Symbol, which creates a block... vs. "it's just syntax sugar for")
What do you think?
We are using this syntax in a new language we are doing, Crystal, which has a syntax very similar to Ruby, and so far we think it's nice, simple and powerful. You can read more about it here: http://crystal-lang.org/2013/09/15/to-proc.html
--
http://bugs.ruby-lang.org/