World: r3wp

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

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