World: r3wp

Except the second one doesn't work :(

Tricky isn't it ?

Not bad ideas though. I think I prefer to use SET, rather than FOREACH, 
to set the record values, to keep the variable length ability.

Mmm... maybe USE-FOREACH better deserves your functionality, and 
USE-FORALL could be a function which steps through the DATA block, 
allowing access to it.

This works:
	use-forall: func [
		words data body
	][
		use words compose/deep [
			forall data [
				set [(words)] bind data/1 'data
				(bind body 'data)
			]
		]
	]
	
	; test
	
	data: [
	
		[code description]
	
		["CC" "Crazy Cuts"]
		["DD" "Dreadful Dingo"]
		
	]
	
	use-forall data/1 next data [
		print index? data 
		if code = "CC" [print description]
	]

>> use-forall [leg arm hair] [["long" "skinny" black]["short" "fat" 
blonde]][?? arm]
arm: "skinny"
arm: "fat"
== "fat"

I think this is pretty sturdy -- an interesting exercise in context 
wrestling:

use-foreach: func [words records body][
    bind body first words: use words reduce [words]
    foreach record records [set words record do body]
]

That's Brazilian bindology, Chris.

why Brazilian, Anton?

anton, chris' way is how i'd probably do it.

Ladislav, a reference to Brazilian ju-jitsu, which is wrestling.

Wait, I haven't shown you this yet.
	; my second version, more like Chris's version, using FORALL
	use-foreach: func [
		words [block! word!]
		data [series!] "The series to traverse"
		body [block!] "Block to evaluate each time"
	][
		use words compose/deep [
			forall data [
				set [(words)] data/1
				(body)
			]
		]
	]

It uses less words, is easier to understand, but it has a more brittle 
dependency chain via FORALL mezzanine which uses FORSKIP mezzanine 
which uses WHILE native.

Oh, and although it uses less words, it spreads them out across more 
lines.

Chris' version does not support WORDS argument as a word! - but I 
don't think it's that important to support.

Gabriele, since you say that, Chris' version does remind me of your 
style of coding.

- Nested blocks in the user code might require BIND/COPY.
- [throw] (?)
- [catch] (?)

- RETURN and BREAK ...

i opt for chris version. its a loop, foreach is faster. but  add 
a version with more lines, for  explanation^^.

Anton, would it add too much to change the 'forall loop to a 'while 
loop?

Fundamentally, I don't see much difference in our separate approaches. 
 Using 'compose certainly makes it easier to read.  (I'm not sure 
why, I seem to have an inherent aversion to 'compose)

Using compose, I could get the word! argument working:

bind body first words: use words compose/deep [[(words)]]

Volker, yep, documentation last, as usual !

Chris, no, I would do it:

; my fourth version, using WHILE
	use-foreach: func [
		words [block! word!]
		data [series!] "The series to traverse"
		body [block!] "Block to evaluate each time"
	][
		use words compose/deep [
			while [not tail? data][
				set [(words)] data/1
				(body)
				data: next data
			]
		]
	]

It's a pity that it uses five more words, but the extra stability 
and simplicity of going direct to a native seems worth it.

(FORALL will be ok, it gets enough usage in normal code. ;-)

; more commented:
use-foreach: func [words records body /local fresh-locals][
    ; make fresh locals for the args
    fresh-locals: use words reduce  [words] ; trick
    ; bind body to one of  the new locals
    bind body first fresh-locals
    ; now loop
    foreach record records [
        set words record 
        do body
    ]
]

Comments good, but I think, don't add them yet. There are still some 
code changes to make yet, I think.

Agreed. Tried to make it  more readable. The original looked like 
magic, but somewhat formatted i find it clear.

(Also, I think adding FRESH-LOCALS is not a good move.)

Was for readibility-demonstration.Would notdo that in the working 
version. but somewhere in the docu.

Agreed, the original did look like magic.

has anybody used core async dns ? I am trying to resolve domains 
using a port per domain but I get a sequential behaviour. Ideally, 
this should be done with a single port, sending requests and getting 
replies in an async fashion. snippet below

f-awake: func [
	port
	/local res
][
	res: 	copy port
	print 	[port/user-data/host res]
	remove	find system/ports/wait-list port
	false
]


b-hosts: [ "www.rebol.net" "www.google.com" "www.yahoo.com" "www.microsoft.com" 
"xxafda" "www.ebay.com" "www.amazon.com" ]
foreach	h b-hosts [
		 p: 	open/no-wait make port! [
				scheme: 	'dns
				host:		"/async"
				user-data:	reduce ['host h]
				awake:		:f-awake
			]
		insert	tail system/ports/wait-list p
		insert	p h
	]
wait 	[]

although dns:///async is asyncronous, it probably can't do multiple 
host resolution at the same time.

i never used it this way, so i can't say if it can be made to work. 
but by thinking about how this is implemented on unix (a second process 
that calls gethostbyname), i'd guess that it can only do one host 
resolution at a time.

only now I noticed, that:

    even? 0.1 ; == true


my understanding differs slightly, I would more likely expect a test 
like:

    zero? 0.1 // 2

any opinions?

I totaly agree.

gabriele, thanks, does your async library handle async dns ?

yes, when you use the async:// protocol the host name is resolved 
asynchronously.

but i never tried what happens if i try to resolve many hosts at 
the same time

(btw, my code is very similar to yours above, so i think you're using 
it correctly.)

http://www.colellachiara.com/soft/libs/async-protocol.r

ladislav, i guess even? and odd? just convert everything to integer?

with your test above, would any non-integer number be odd?

odd - well, another possibility is to say that ods is not even

ladislav yes, ods is not even, ods is odd, but i think that not-czechs 
can't understand ;-]

:-))

sorry for the typo