World: r3wp

That has a couple problems but you are on the right track, Steeve 
:)

this is a little higher level rebol that I currently know, but very 
interesting to learn some new things

wow, compose is very interesting function

and if you always use the same vars (like x, y and z) you can simplify:

 map: func [list exec /local res][res: copy [] do reduce [:foreach 
 intersect [x y z] exec list compose [append res (exec)]] res]
>> map [1 2 3 4][x * x]
== [1 4 9 16]
>> map [1 2 3 4][x * y]
== [2 12]

Oh, that is "fixing" it in the wrong direction :(

ahah, i know, you can't anymore use inner parents or brackets ;-)

Nope, I was talking about 'res capture the first time, but you have 
added keywords in the second.

don't see your point, what do you mean with res ?

oh you say i can't use res as var ?

In your first version, you have a problem if the vars list includes 
the vars 'append or 'res. You need to compose your loop differently.

In your second version, everything after the "and if" part of the 
message was a bad idea for a library function :)

oh i see...

map: func [vars list exec /local res][res: copy [] do reduce [:foreach 
vars list compose [append (res) (exec)]] res]
is that ok now ?

Still has the problem with 'append.

ahah, you want 'append as var too ?

map: func [vars list exec /local res][res: copy [] do reduce [:foreach 
vars list compose [(:append) (res) (exec)]] res]

Let me look at it for a sec (unless you want to do it - this is the 
School group).

Start with this spec from R3:
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"
] [...]

hum seems it's bugous, right...

It's native in R3, but if we get this right it could be a mezz backport 
in a future R2 release.

(this is beyond me but I will hapily watch)

( aha, 'word is how you can recieve word without evaluation ...  
a: func [ 'word val ][ set word val ] -- cool )

OK, the words are set using block set semantics:
>> set [a b] [1]
== [1]
>> a
== 1
>> b
== none

>> map [a b] [1 2 3] [a * b]
** Script error: * does not allow none! for its value2 argument
** Where: map
** Near: map [a b] [1 2 3] [a * b]

i saw...

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