World: r3wp

simpler:

map: func [vars list exec][do reduce [:foreach vars list reduce [:append 
[] :do exec]]]

Note that all functions of this type have bind/copy overhead of the 
code block (including FOREACH).

>> map [x][1 2 3 4][x * x]
== [1 4 9 16]
>> map [x y][1 2 3 4][x * y]
== [2 12]

yes Brian

Try to source that last version after running it a few times.

i see nothing...

there no need of copy , it's copied by the reduce

No, by the foreach.

It's inserted as-is by the reduce.

hum ok

(The teaching stuff is for Janko :)

i thought it was strange

and finaly, we can use a single var:

map: func ['vars list exec][do reduce [:foreach to-block vars list 
reduce [:append [] :do exec]]]

>> map [x][1 2 3 4][x * x]
== [1 4 9 16]
>> map x [1 2 3 4][x * x]
== [1 4 9 16]

is it ok now Brian ?

The outer do reduce is unnecessary now, but I see no problems :)

it's only missing checking of allowed types

why it is no necessary ?

oh !

i don't see...

foreach need that trick

foreach allow only single var or a block of vars (he can't use the 
result of an evaluation)

For that matter, the to-block is also unnecessary. Try this:

map: func ['vars list exec][foreach :vars list reduce [:append [] 
to-paren exec]]

That handles the 'do capture too :)

argh...

right

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