World: r3wp

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.

even with [to block!] ?

the native one...

(thanks for interesting discussion and code, I have to go to sleep 
it's almost morning here), I will use map a lot :)

Yeah. The either trick saves 20 milliseconds and some memory too, 
on my slow computer.

22 to 33 milliseconds, depending on input.

it's a shame 'either has a so verbose form ;-)

This isn't C :)

nite Janko

it"s hard work to optimize such short mezzanine

but it's funny too

Indeed it is both, but well worth it :)

for my personnal use, i would have an option to modify the input 
serie instead of creating a new one

The R3 FOREACH is used for that.

Still, good idea :)

an /keep refinement on map ?

/no-copy

i want to see :)

i try...

I did some testing and found that, as a general practice, the /into 
option leads to code with less overhead than the /no-copy option.

The implementation tends to be smaller too, as change-in-place code 
looks very different than fill-something code.

hum, really ?

Using /into for your functions leads you towards reusable buffers 
and incremental building. The /no-copy option tends towards template 
copying. I mean, as the option is used generally.

do you mean by default map should do change ?

Let me show you MAP with /into.

oki

not so easy ? :)

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"
    /into "Collect into a given series, rather than a new block"
    output [series!] "The series to output to"
] [

    unless into [output: make block! either word? word [length? data] 
    [divide length? data length? word]]

    foreach :word data reduce [:insert :tail output to paren! body
    output
]

Sorry, forgot the ] after the foreach

Sorry again, wrong semantics.

hum, i see now, you don't update the input data.

The /into option is supposed to have INSERT semantics, not INSERT 
TAIL.