(This is a snapshot of my old weblog. New posts and selected republished essays can be found at raganwald.com.)
Friday, October 26, 2007
map(&"(1.._).inject(&'*')")
Some working Ruby code:
See String#_to_proc.
Some working Ruby code:
(1..3).map(&'*2') => [2, 4, 6]
(1..3).map(&'[-1, _, 0]') => [[-1, 1, 0], [-1, 2, 0], [-1, 3, 0]]
(1..3).map(&'x -> y -> x * y').map(&'[2]') => [2, 4, 6]
(1..5).select(&'>2') => [3, 4, 5]
(1..3).map(&'x -> y -> x * y').map(&'.call(2)') => [2, 4, 6]
[5].map(&"(1.._).inject(&'*')") => [120]See String#_to_proc.
Comments on “map(&"(1.._).inject(&'*')")”:
<< Home
That's some pretty cool stuff, but I can't see what's happening here:
(1..3).map(&'x -> y -> x * y').map(&'[2]') => [2, 4, 6]
(1..3).map(&'x -> y -> x * y').map(&'[2]') => [2, 4, 6]
(1..3).map(&'x -> y -> x * y').map(&'[2]') => [2, 4, 6]
x -> y -> x * y:
y -> x * y produces a function that multiplies some number, x times a parameter, y.
x -> ... produces a function with a parameter, x.
x -> y -> x * y produces a function with a parameter, x. It returns a function that multiplies x by a parameter, y.
So 1..3).map(&'x -> y -> x * y') produces an array of three functions, one that multiplies by one, one that multiplies by two, and one that multiplies by three.
[2] produces a function that takes its argument and calls the [] method passing two.
For procs in Ruby, [] is a synonym for call.
So .map(&'[2]') actually takes each function in the list and calls it with the parameter 2.
Thus... [2, 4, 6] is multiplying two by 1, 2, and 3.
x -> y -> x * y:
y -> x * y produces a function that multiplies some number, x times a parameter, y.
x -> ... produces a function with a parameter, x.
x -> y -> x * y produces a function with a parameter, x. It returns a function that multiplies x by a parameter, y.
So 1..3).map(&'x -> y -> x * y') produces an array of three functions, one that multiplies by one, one that multiplies by two, and one that multiplies by three.
[2] produces a function that takes its argument and calls the [] method passing two.
For procs in Ruby, [] is a synonym for call.
So .map(&'[2]') actually takes each function in the list and calls it with the parameter 2.
Thus... [2, 4, 6] is multiplying two by 1, 2, and 3.
It looks like 'x -> y -> x * y'.to_proc returns a curried function (proc) with 1...3 already applied to x (in the first map), and the second map then goes about to apply the 2 to y for each of the partial functions.
...I think.
...I think.
Just for giggles, the new VB syntax for that.
Dim a = From i In Sequence(1, 3) Select i * 2
Dim b = From i In Sequence(1, 3) Select New Integer() {-1, i, 0}
Dim c = From i In Sequence(1, 3) Select x = Function(y) i * y Select x(2)
Dim d = From i In Sequence(1, 5) Where i > 2
Dim e = From i In Sequence(1, 3) Select x = Function(y) i * y Select x(2)
Dim f = (From i In Sequence(5, 5) Select seq = Sequence(1, i) Select Aggregate j In seq Into Product())
Dim a = From i In Sequence(1, 3) Select i * 2
Dim b = From i In Sequence(1, 3) Select New Integer() {-1, i, 0}
Dim c = From i In Sequence(1, 3) Select x = Function(y) i * y Select x(2)
Dim d = From i In Sequence(1, 5) Where i > 2
Dim e = From i In Sequence(1, 3) Select x = Function(y) i * y Select x(2)
Dim f = (From i In Sequence(5, 5) Select seq = Sequence(1, i) Select Aggregate j In seq Into Product())
Thanks Reg and rubyruy, those are good explanations. In fact, I thought the post after this one made it more clear as well.
<< Home
