World: r3wp

Brian, how much would you size the preallocating ?

half of the intial serie length ?

map: func [

    {Evaluates a block for each value(s) in a series and returns them 
    as a block.}

    'word [word! block!] "Word or block of words to set each time (local)"
    data [block!] "The series to traverse"
    body [block!] "Block to evaluate each time"
] [

    foreach :word data reduce [:append make block! either word? word 
    [length? data] [divide length? data length? word] to paren! body]
]

humm, really accurate

That expression is faster than the reallocations for large data.

agree

map: func [
    [throw]

    {Evaluates a block for each value(s) in a series and returns them 
    as a block.}

    'word [word! block!] "Word or block of words to set each time (local)"
    data [block!] "The series to traverse"
    body [block!] "Block to evaluate each time"
] [
    foreach :word data reduce [

        :append make block! either word? word [length? data] [divide length? 
        data length? word] to paren! body
    ]
]

I would change the append to insert tail just because it is faster.

yep, agreed too

Yeah, I forgot that append is mezzanine in R2 :(

even shorter with a to-block instead of either:
foreach :word data reduce [

        :insert :tail make block! divide length? data length? to-block word] 
        to paren! body
    ]

to-block has block copy overhead, but yeah.

it's just for intialisation... ;-)

*during

/me quietly files into the lecture hall and sits down as a crowd 
gathers ...

I'll profile to see which is faster. We already have block creation 
overhead with the reduce and to-paren.

Actually, as overhead goes the to-block would be minimal in comparison 
:)

But I would go with the more efficient code in that situation since 
it would be a mezz

We can care less how long the code is in a mezz as long as it performs 
at the optimum.

Brian, i wonder what will be the overhead if map was a mezzanine 
in R3 (you should test that too) ?

Since the profiling functions are better in R3, I am comparing the 
differences there.

The either is faster.

pick is usually faster than either when eithers first argument is 
logic based.

which in this case it is

ahah, i was thinking about pick too

Yes, but we have to calculate. Let me check that too.

but in that cas we have to pre-calculate length? data

Yes, I agree, alwasy profile - never assume

at least when building mezzanines.

I still want to backport the profiler to R2.

length? pick reduce [[1] data] word? word
but there is an overhead too

Here's the fastest version for R2:
map: func [
    [throw]

    "Evaluates a block for each value(s) in a series and returns them 
    as a block."

    'word [word! block!] "Word or block of words to set each time (local)"
    data [block!] "The series to traverse"
    body [block!] "Block to evaluate each time"
] [
    head foreach :word data reduce [

        :insert :tail make block! either word? word [length? data] [divide 
        length? data length? word] to paren! body
    ]
]

btw: python was recieving criticism because guido made it more and 
more awkward to use functional programming , which wasn't handeled 
that well previoulsly either. The way you added a powerful (with 
variable number of params) map that looks like native in other languages 
really speaks something about a language. Interestingly this article 
about python also mentions REBOL http://lambda-the-ultimate.org/node/2302

Interesting to see how much optimization expands the code, isn't 
it?

yes :)

and [divide a b] is faster than [/ a b] ?

lol

LENGTH? is prefix, so to use the infix / you would need parens, which 
have overhead.

I wouldn't use prefix / in a mezzanine - bad form.

in R2 / works as prefix too

I can't profile them for comparison, because bad form like that has 
not removed from R3, where my profiling functions are better.

anyway...

has not -> has

it was a joke

has not -> has been

I am bad at typing today. Let's not corrupt people in the school 
group :)

Speaking of which, good catch on the foreach bind/copy eliminating 
an explicit copy :)

yeah, i think too, i will have to remember that trick next time

Couldn't use it here efficiently, but a good trick nonetheless :)

Btw, on R3 that EITHER WORD? trick has half the overhead of the TO-BLOCK 
method.

Not much either way, but we count our miliseconds when writing mezzanines.