World: r3wp

Many already have REBOL equivalents, named differently. REBOL was 
not designed by functional programming enthusiasts.

I got used to them so if something is can be cleanly solved by one 
of them and I have to write some temprorary variables and foreach 
loops feel bad :)

R3 has major improvements to FOREACH - it will get used a lot more 
:)

yes, that's why I was asking, you have all sorts of interesting thigns 
like do, reduce (rebol's), I have seen apply in R3 , so I see there 
should be a lot of interesting stuff possible but don't have a clear 
picture what is and what isn't yet

good

this seems to work as simple map   fpmap: func [ series mod ] [ new: 
copy [ ] foreach item series [ append new mod item ] new ]

fpmap [ 1 2 3 ] func [a][ a * 100] == [100 200 300]

For the simple case of an argument function taking one parameter, 
sure.

well your R3 map will surelly be more powerfull, but it's nice to 
know I can make simple HOFs in R2 too

I mean map that you made examples off

fpreduce: func [ series samp mod ] [ foreach item series [ samp: 
mod samp item ] samp ]           fpreduce [ 1 2 3 ] 0 func [s a][ 
s + a] == 6

You can make REBOL-style control functions like R3's MAP in R2 too.

really? that would be nice, I imagine I "do" the block , but before 
I have to somehow set those variables, I mean words

but that I have no idea how ... probably something with set, but 
how do I take the words

in R2:

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

hm, vary interesting

vary = very

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.