[ruby-talk:7111] Re: "map_with_indices" and related musings

David Alan Black writes,

# So many recent discussions here of Array (and/or Enumerable) methods 
seem to
# involve arrays knowing how to do things with other arrays, generally in 
exact
# alternation: interleaving, hashing themselves against their own indices,
# getting iterated over at the same time....
<...>
# I wonder whether there's some
# unifying, underlying Thing that all these problems we're solving are 
mutually
# doing.  If so, what exactly is that Thing (interleaving with self's 
indices?) and
# can the cluster of methods we've been talking about (interleaving, 
to_hashing,
# etc.) be factored and constructed, as a group, to reflect that unity?

Well, you might call that Thing "generalized parallel vector 
processing".These sorts of things are reminiscent of the increasingly 
complex sorts of pipeline vector operations seen on some ancient 
generations of supercomputers.  Which in turn is (among other things) a 
low-dimensional slice of generalized parallel array processing. 

Which is reminiscent of the "APL view of reality", whose (sort of) 
successor is J:

    http://www.cs.ualberta.ca/~smillie/Jpage.html
    http://www.jsoftware.com/

I haven't spent much time looking at Jay, but I think you could still 
realistically view J as one attempt to abstract and systematize the sorts 
of things you're after (plus much, much more--maybe way too much more). It 
might not be a good OO model, but it might help illuminate the abstract 
terrain that you want to cover. 

Conrad Schneiker
(This note is unofficial and subject to improvement without notice.)