to_proc
Ruby to_proc
Ruby blocks are powerful. You can easily convert an array of numbers to strings:
[1, 2, 3].map { |n| n.to_s } #=> ["1", "2", "3"]
Of course, you can also do this with this shortcut:
[1, 2, 3].map &:to_s #=> ["1", "2", "3"]
The & operator converts an object to a Proc suitable to be
passed as a block. You can make any class respond to this operator by implementing
a to_proc method. Symbol has a to_proc
method.
This is all very nice but what if you want to pass an argument to the method. For example:
[10, 20, 30].map { |n| n.modulo(3) } #=> [1, 2, 0]
Can we write something like &:modulo(3) to make it work? It turns out
you can’t, at least
not that easily.
Not only that, but since Ruby has to convert the Symbol to a Proc there’s a slight performance penalty over doing it with a normal block.
Finally, Ruby’s implementation of Symbol#to_proc has a cache of Procs so they are not created every time you use the same symbol, but still, it’s slightly slower than a normal block.
Crystal to_proc?
At first we thought about making Crystal have the same syntax for this, but a bit hacky: if you
do &:to_s, because the argument to & is a Symbol we can rewrite the source code to receive a block:
# This:
[1, 2, 3].map &:to_s
# is rewritten to this:
[1, 2, 3].map { |x| x.to_s }
For other arguments, we would do something different (for example convert a function type to a block).
Fortunately, waj came with a better proposal: what if we write it like
&.to_s?
[1, 2, 3].map &.to_s
Now, this is a new syntax, different from Ruby. If you do this in Ruby…
irb(main):001:0> [1, 2, 3].map &.to_s
SyntaxError: (irb):1: syntax error, unexpected '.'
[1, 2, 3].map &.to_s
^
This means that placing a dot after the & makes no sense in Ruby, which also means that this syntax
is available for giving it a new meaning. So in Crystal we chose to use this syntax instead.
With this little change, we can pass arguments to the method very easily:
[10, 20, 30].map &.modulo(3) #=> [1, 2, 0] ... but only in Crystal ;-)
Not only that, but you can also write this:
[1, 20, 300].map &.to_s.size #=> 1, 2, 3
Or this:
[[1, -2], [-3, -4]].map(&.map(&.abs)) #=> [[1, 2], [3, 4]]
And of course this:
[1, 2, 3, 4].map &.**(2) #=> [1, 4, 9, 16]
The best thing is that this is just a syntax rewrite without any performance penalty.