World: r3wp

i forget the :vars trick, damn...

at the end you two will have just map: func [ ] [ ] and it will work 
:)

shame on me

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 [] to-paren body]
]

Try it :)

I can just say wow to both

that's good

Add a [throw] attribute and it will be good enough for a mezzanine 
:)

as i said before Janko, just some instructions, ;-)

very cool, this would deserve another blogpost

I'll post it to DevBase in the R2 section.

the trick about the no need of an intial copy [] when we use foreach 
is so cool

so rebolish

and I just wrote the code with double map instead of double foreach 
and it looks much more elegant ... no collector values no explicit 
returning then , it would be great if this would be in rebol IMHO

Not too much overhead compared to native MAP. We could cut down on 
memory overhead by preallocating the destination.

that part [] and to-paren is something I still need to explore and 
I need to get better understanding of :word 'word .. etc

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?