Dominik Bathon
6/8/2005 11:25:00 PM
Obviously no one really likes to decipher undocumented code... (I should
have known after the "Code Cleaning"-Quiz ;-)
Well, so let me tell you what it does:
As James Britt already figured out, it lets you call one method on all
elements of an Array. If no block is given this works like collect.
Instead of
[-1, -2, -3].collect { |x| x.abs }
=> [1, 2, 3]
you can just write
[-1, -2, -3].abs
=> [1, 2, 3]
Since #abs is not part of the Array interface, method_missing is
triggered. But it does more than collect, it even works on nested Arrays:
[[-1,-2],[-3,4],-2,5].abs
=> [[1, 2], [3, 4], 2, 5]
If you try a method that is part of Array's interface, method_missing
obviously won't be called:
%w[abc de fghi].size
=> 3
But there is a trick (maybe hack):
%w[abc de fghi]._x_size
=> [3, 2, 4]
The optional "_x_" is automatically stripped. But this also has a
downside, it doesn't work with nested arrays, but on the other hand you
can choose an explicit depth:
[[[1,2,3], "iuhiu"], ["iu", [4,5,6]]]._x__x_size
=> [[3, 5], [2, 3]]
But methods also can get arguments, so how are they handled? Some examples:
%w[abc de fgh ijk].ljust(5)
=> ["abc ", "de ", "fgh ", "ijk "]
%w[abc de fgh ijk].ljust((4..8).to_a)
=> ["abc ", "de ", "fgh ", "ijk "]
%w[abc de fgh ijk].ljust(5, %w[1 2 3 4])
=> ["abc11", "de222", "fgh33", "ijk44"]
%w[abc de fgh ijk].ljust([5, 3, 5, 6], %w[1 2 3 4])
=> ["abc11", "de2", "fgh33", "ijk444"]
I think you can get the idea.
But all this was just the beginning ;-)
My motivation to write this actually was to be able to say
[3, 3].times { |x, y|
p [x, y]
}
instead of
3.times { |x|
3.times { |y|
p [x, y]
}
}
Well, now I can. And of course you can combine this with the above:
[1,2].upto(4) { |*a| p a }
output:
[1, 2]
[1, 3]
[1, 4]
[2, 2]
[2, 3]
[2, 4]
[3, 2]
[3, 3]
[3, 4]
[4, 2]
[4, 3]
[4, 4]
[1,2].upto([2, 3]) { |*a| p a }
output:
[1, 2]
[1, 3]
[2, 2]
[2, 3]
[%w[a b c], [1, 2, 3]]._x_each { |*a| p a }
output:
["a", 1]
["a", 2]
["a", 3]
["b", 1]
["b", 2]
["b", 3]
["c", 1]
["c", 2]
["c", 3]
If multiple arguments would be yielded to the blocks, they are grouped by
arrays:
[%w[a b c], 1..3]._x_each_with_index { |*a| p a }
output:
[["a", 0], [1, 0]]
[["a", 0], [2, 1]]
[["a", 0], [3, 2]]
[["b", 1], [1, 0]]
[["b", 1], [2, 1]]
[["b", 1], [3, 2]]
[["c", 2], [1, 0]]
[["c", 2], [2, 1]]
[["c", 2], [3, 2]]
Because I wanted the multidimensional iteration, it doesn't work nice with
things like collect:
[%w[a b], 1..2]._x_collect { |*a| a }
=> [[[["a", 1], ["a", 2]], [["b", 1], ["b", 2]]], [["b", 1], ["b", 2]]]
Maybe I should add another special prefix ( ;-) ) so that it works more
like the non block version. Maybe like this:
[%w[a b], 1..2]._y_collect { |*a| a+a }
=> [["aa", "bb"], [2, 4]]
Or maybe use _i_ for the multidimensional iteration and _x_ for the rest...
I also thougt about adding it to Enumerable, but I think it doesn't make
to much sense for other Enumerables (like Ranges) and if you really need
it you can always use #to_a.
I realize there are lots of inconsistences in this concept, but I really
like it generally. So, what do you think?
Dominik