World: r3wp

Steeve, I know. You can do everything with PARSE in only 10 times 
as much code as with a single mezz. :-)

Parse - we first need all those handy enchancements being implemented 
:-)

R2 backports of the R3 reflection functions are now done.

So - are we heading towards new R2 release?

That's REFLECT and its associated *-OF functions. Yes, gradually, 
as R3 gets fuurther along. The backports can be used with existing 
releases though - I'm bundling them all into %r2-forward.r.

I also backported CAUSE-ERROR, which triggers errors safely.

Also the proposed QUOTE and ACCUMULATE.

quote ?

accumulate -> cumul (shorter name)

QUOTE is a Peta special, a simple function to perform a nasty trick 
in as little code as possible. It blocks evalation :)

; R3 version
quote: func [
	"Returns the value passed to it without evaluation."
	:value [any-type!]
] [
	:value
]

; R2 version
quote: func [
	"Returns the value passed to it without evaluation."
	:value [any-type!]
] [
	get/any 'value
]

It's like the Scheme function of the same name.

evalation -> evaluation

CUMUL is not an English word (but let me check). I picked ACCUMULATE 
because it is the industry standard (for procedural langs).

oh sorry it's french (i tried)

We are not going the Perl 6 route :)

I'm checking a thesaurus.

and ACCU ?

GATHER perhaps?

http://en.wikipedia.org/wiki/ACCU

BrianH, check #1804, for a GATHER function that does something else.

That sounds like a better function to call GATHER. ACCUMULATE will 
get called less than that.

It could use the /into option though.

With all of these collection synonym functions it will be interesting 
to keep them straight.

Use FORALL for the R3 version of GATHER - FORALL is faster than FOREACH 
in R3.

ASSEMBLE might be a nice word to reserve.

Could be disturbing for beginners, a same thing can be writed  using 
so many various ways with the tons of mezz we have now.

Yeah. For an assembler :) We want reserve COMPILE too :D

Steeve, you have a point. For a couple of years, I would write mezzanines 
for things that already existed in R2, but hadn't noticed.

ahah, shame on you ;-)

I'm converting GATHER to mezzanine/library code standards now. We'll 
probably put all of these is an advanced series manipulation library 
module.

types-of is ugly Brian :)

You have no idea. TYPES-OF was the only reflector that had no corresponding 
hack in R2. I had to do it from scratch.

Mezzanine-quality version of Henrik's GATHER, R3 version:

gather: func [
	"Get the values of a given field from all objects in a block."
	block [block!]
	word [word!]

 /into "Insert into a buffer instead (returns position after insert)"
	output [series!] "The buffer series (modified)"
][
	unless output [output: make block length? block]
	forall block [
		all [
			object? block/1
			in block/1 word
			output: insert/only output select block/1 word
		]
	]
	either into [output] [head output]
]

Has the spec for make function! been changed on purpose in R3? Is 
for what reason?

Is => if

>> a: make function! [spec] [body]

** Script error: cannot MAKE/TO function! from: function!

** Where: make

** Near: make function! [spec] [body]

>> my-func: make function! [[b] [print b]
]
== make function! [[b][print b]]

Yes. Reason: To simplify and speed up MAKE, and REBOL, and to make 
code generation easier.

Use the wrappers if you want to be R2 compatible.

Brian, are you sure that (output: insert/only output ..) is faster 
than (append/only output) in R3 ?

No, it's not, but not by much and it's necessary for the /into option.

ah yes, i forget

Strangely enough the REBOL overhead of the /into option (one UNLESS, 
one EITHER, and n assignments) is dwarfed by the overhead saved if 
the /into option is implemented pervasively.

Plus, I can copy-paste most of the code :)

and you say that foreach is slower than forall in this case ? (overhead 
with 3 path evaluations block/1 , no ?)

BrianH, nice GATHER function. :-)

FOREACH does a BIND/copy of its code block, but you might have a 
point in this case because the 3 paths are N*3.

Final submitted R3 version:

gather: func [

 "Get the values of a given field from all objects in a block that 
 have it."
	block [block!] "A block which may contain objects"
	word [word!] "The field to look for"

 /into "Insert into a buffer instead (returns position after insert)"
	output [series!] "The buffer series (modified)"
][
	unless output [output: make block length? block]
	foreach item block [all [
		object? :item
		in item word
		output: insert/only output select item word
	]]
	either into [output] [head output]
]

So FOREACH is better, anyway?

not anyway

Argh, I need to read better. You wrote this already.