I came up with a nice new(?) use for method_missing today.
Now it is your job to figure out what you can do with it.
(My hope is that someone will find nice uses for this, that I didn't think  
of)

So here is the code:

class Array
     def method_missing(meth, *args, &block)
         rmeth = (meth.to_s =~ /\A_x_(.*)/ ? $1.to_sym : meth)
         if block
             if empty?
                 []
             else
                 mm_block_rec(rmeth, 0, res=[], [], *args, &block)
                 res
             end
         else
             res=[]
             each_with_index { |el, i|
                 res << el.send(rmeth, *(args.collect { |el|
                     (Array === el) ? el[i] : el
                 }))
             }
             res
         end
     end

     private

     def mm_block_rec(rmeth, i, res, bargs, *args, &block)
         myargs=args.collect { |el| (Array === el) ? el[i] : el }
         res[i] = self[i].send(rmeth, *myargs) { |*ba|
             bargs[i]=(ba.size==1 ? ba.first : ba)
             if i==size-1
                 block.call(*bargs)
             else
                 mm_block_rec(rmeth, i+1, res, bargs, *args, &block)
             end
         }
     end
end

And some questions:

What does it do?

What can it be used for?

Has this been done before? (I couldn't find anything.)

Do you like it?

Rather than have
    receiver.message( args )

I wanted to reverse things and do
   message( args )->[ list_of_receivers ]

I hacked on Symbol and the result was that I could loop over a set of
objects, or use a proc to conditionally send the message to objects in
ObjectSpace (i.e., "I know what I want to do, I just don't know who to
do it to").  The results were then collected and returned as an array.

The call looked something like

:message.>>( obj_set_or_criteria_proc ) { args }

I never found a really practical application for this.  Conceivably, one
could close all open file handles, or shut down lingering socket
connections, or save user sessions if the session was x minutes old, or
whatever.

It was mostly a "Gee, I wonder if ..." sort of thing, and the best
scenario I could think of was if I had an app that might need a global
shutdown, so one might want to dispatch a common set of messages across
a range of unknown objects before ending.

I never released the code, being unhappy with the syntax.  But I still
like the idea of casting a message out into object space and reeling
back the results.

BTW, I tried out your code, with a trivial example:

p %w{  This is some text }.size

Ah, but, of course, method_missing never gets called, so I did not get
what I wanted.

This works, though:

p %w{ This is some text }.upcase

So there is the issue of trying to distribute a method across the list
when that method is also implemented by  Array

James

--

module Enumerable
     alias __original__map__ map
     def map(*args, &block)
               if args.length > 1
                       __original__map__ { |obj| args.inject(obj) {
|o, meth_sym|

              o.send(meth_sym) }
                        }
                else
                         __original__map__(&block)
                end
     end
end

so we have [ ' hello   ', ' world', ' !    '].map(:upcase, :strip)

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]

3.times { |x|
     3.times { |y|
         p [x, y]
     }

[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?

regards,

Brian