World: r3wp

You appear to be doing a very good job of it, overall, don't get 
me wrong. I wish you'd see my point of view with respect to other 
(future) users who will view the code in the console, not in some 
source file locatable somewhere if you're lucky and the RebDev chat 
server is still running.

DevBase is where the source will be, with full history. It's one 
of the primary features of R3. It's not going away.

I mean, we'll probably have source packages and we will have DocBase 
and the manual, but DevBase is where the source is.

what does assert return when all is ok?  true?

Yes. If it's not OK it throws an error. After an assert you can count 
on the conditions being true.

is there a none returning version of assert... a bit like first vs 
pick ?

all intersting stuff btw.

Yeah. ALL.

And FIRST returns none in R3. We're trying to make the errors more 
useful and meaningful in R3.

that would mean less errors? but better ones?

Yup :)

cool.

does ALL also support the /type refinement in R3 ?

now you see... I'm all fired up on R3 and I've stoped working for 
the past hour.... ;-)  glass is now an hour behind schedule ;-)

Nope, but SWITCH TYPE?/word does (effectively).

Or FIND typeset! value.

my first R3 func ....   valid?: func [spec][attempt [assert spec]] 
  ; -)

so I can assert within any/all blocks  ;-)

valid?: func [spec /type][attempt [apply :assert [:spec type]]]

yess apply that is a great addition to R3   8-D

Already backported to R2-Forward.

must be a bit slow though... is it?

R2-Forward is also in DevBase (and has *lots* of comments).

The R2-Forward APPLY is not as fast as the native, but I've found 
it fast enough for wrapper functions in R2.

Plus it disables the special treatment of 'a and :a declared parameters.

is that gone in R3?  (set word arguments)

Nope, they just work better.

Don't forget to keep it simple! As simple as possible, but not simpler.

Is there a way in R3 to "capture" error messages when using ATTEMPT, 
or some other command.
i.e.
>> WRITE %missing/File.txt to-binary "test string"
** Access error: Cannot open: %missing/File.txt reason: -3
** Where: WRITE
** Near: WRITE %missing/File.txt to-binary "test string"

>> ATTEMPT [WRITE %missing/File.txt to-binary "test string"]
== none

Is there any way to get the error message from the ATTEMPT?

Found it!

>> probe disarm try [WRITE %missing/File.txt to-binary "test string"
make object! [
    code: 500
    type: 'Access
    id: 'cannot-open
    arg1: %missing/File.txt
    arg2: -3
    arg3: none
    near: [WRITE %missing/File.txt to-binary "test string"]
    where: [WRITE try]
]
== make object! [
    code: 500
    type: 'Access
    id: 'cannot-open
    arg1: %missing/File.txt
    arg2: -3
    arg3: none
    near: [WRITE %missing/File.txt to-binary "test string"]
    where: [WRITE try]
]

in R3 is there a way to intercept the write event before the send 
occurs - and if not, is there a way to force a send before another 
write takes place in an Async queue?  I'm getting an issue where 
multiple write events are being cached and sent all at once (about 
10 write events per second).

What I think most people do is this:

if error? set/any 'err try [            ][
	probe mold disarm err
]

Is there any advantage to using set/any over a set-word ?

I'm not sure what you mean. They're unrelated.

if error? err: try [  ][
   print mold disarm err
]

I've always used the second way, but almost everywhere else, I see 
others use set/any

Ah, I see now *a* set-word!. :-\  Consider an unset! result:

>> if error? err: try [()] [print mold disarm err]
** Script Error: err needs a value
** Near: if error? err: try [()]
>> if error? set/any 'err try [()] [print mold disarm err]
== none

Ohhkay, guess I've just never run across it.  Thanks

Is there any way in R3 to optimize code such as 


 out: insert insert insert insert insert [] 'fill-pen color [text 
 vectorial] 0x0 "hello"


?  I think the appearance of n INSERTs is kind of ludicrous. People 
are doing this for performance reasons, so the usual way we would 
optimize the code (which produces an intermediate block), isn't an 
answer.

I've forgotten if R3 has any way. (A quick look at APPLY and MAP 
doesn't seem to bear any fruit.)

it's not more fast than using a reduce or a compose.

but it saves memory overheads, exspecially in big loops

---> thus, does become a speed issue.

It would be nice to be able to say:

	loop 5 [insert] [ ] v1 v2 v3 v4 v5

so no intermediate block is generated.

Or have a method of reducing only the items in a block as they are 
being applied, without generating a new temporary block to hold them.

(This idea has been discussed before, somewhere...)

About the loop 5 example; I remember Carl saying that would break 
the rebol evaluation rules, or something like that.
But could we get that functionality some other way?

i think a reduce that can not creates a new block is not interesting, 
because the same block can not be anymore reduced next.

so, you can't use it in a loop

but an insert fonction which can reduce all the values from a a block 
before adding them, is quite interesting.