World: r3wp

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.

It seems like speed is more important than memory in this function.

Henrik, if you can write up a CureCode wish for this function I can 
mark it as pending.

For GATHER? Should I just copy your code and credit it to myself? 
:-)

yes, we all do that :)

Write up a descriptive request, explaining why you need it, or reference 
your R3 chat message number.

Sounds bureaucratic, but OK :-)

CureCode is documentation of the new functions. We need the bureaucracy 
for the users' sake.

If we don't have a record of why the function was added we won't 
know where to puut it when we modularize R3.

Posted.

Henrik, don't forget to add: "Approved by the politburo"

:-)

And 10 lines for signatures.

That's my job (read the ticket comments :)

Curecode needs a trigger for rebdev links.

It will get one, but for now I say something like "R3 chat 1436".

That is the /into option message, so I remember it :)

Here's the R2 version of GATHER:

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? get/any 'item
		in item word
		output: insert/only output get/any in item word
	]]
	either into [output] [head output]
]

Do you want a /deep option?

That will require switching to PARSE for speed.

I don't think it's worth it.

for me it makes the most sense to gather values from a particular 
level.

We can always add another CureCode wish for /deep if we need it. 
The current function is fast, so that's nice.

I marked the ticket as pending, with the particular submitted files 
that contain it.

I think there is merit for a cookbook recipe which briefly describes 
a table of all block manipulation functions, or we have a way in 
HELP to relate these functions, so they become very visible to beginners. 
The problem is that beginners are not likely to be looking for them, 
because they don't expect them to be there. They were created by 
experienced users who have been coding REBOL for years.

Breaking them up into modules will make it easier to understand - 
digestible chunks.

will there be something like mezz fold/reduce function for r3? I 
would use it a lot

Fold is called ACCUMULATE - only functional languages call it fold.

ACCUMULATE is basically fold-left.