$sum = reduce(+) @array;             # macro
   $sum = reduce &infix:<+> @array;     # regular sub
   $sum = [+] @array;                   # meta operator
   ($sum = 0) >>+=<< @array;            # hyper tricks

   use My::Cool::Reduce::Mixin; # unless in core
   $sum = @array.reduce(+);             # macro-ey method

There can never be too many ways to do it, but as one who hasn't been able
to keep very current with perl6l lately, I think a particularly relevant
question we should be asking a lot is, "How long will it take someone
reading that code to figure out what it means?"

The nice thing about "reduce" is that it is easy to find in the index.
"[+]" will not be in the index, although I'm sure it would be the first
thing one would look for.  I'm not sure how many other things a newbie
will try before looking up "metacircumfix:<[ ]>" or however that is

Also in the same light, I am not convinced that reduce is used often
enough to deserve a shorter huffman encoding.  Sure it makes that fancy
slice shorter, but how much headscratching is required for a human to
parse that shortness?

Personally, I think this would be more readable, in part because the
object paradigm is widely understood.

    @foo[0..9; @array.reduce(&infix<;>) ; 0..9];
    @foo[0..9; @array.reduce(;) ; 0..9];

I actually kinda like the idea, in spite of coming across as a naysayer
here.  It just seems like an idea that should be in a module instead of in
core, which seems like an awful strange thing to say to $Larry.

~ John Williams

P.S.  I like [+] better than \\+ because I cannot figure out what \\ would
be mnemonic for.

P.P.S.  We can't use (R)+ ... it's already trademarked!  :)

Reply via email to