World: r3wp

Thank you for all your comments. I'll try them out.

How about a /native refinement to return files in 'request-file to 
return files in the native file format?

Why not just write a TO-LOCAL-FILES function to do that for all files 
in a block ?

because it means I could do this

show-text field form any [ request-file/only/native copy "" ]

and not get "none" in the field

umm.. let me rephrase that!

>> form to-local-file any [%hello %""]
== "hello"
>> form to-local-file any [#[none] %""]
== ""

form any [ to-local-file request-file/only/native copy "" ]

form any [ to-local-file request-file/only copy "" ]

which errors if request-file returns none

This doesn't:
form to-local-file any [request-file/only %""]

ahh.. :)

Too easy, eh ?

yeah .. but I think it would be good to still have the switch as 
it reduces the work.

mmm... I'm not convinced.

it's a switch to control what is being returned by a function

I'd like an inverse of the 'case function.  It goes through conditions 
and evaluates the associated block if the condition is *false*.  
The following does what I need:

inverse-case: func [conditions [block!] /local test][
    while [not tail? conditions][
        set [test conditions] do/next conditions
        either test [
            conditions: next conditions
        ][
            return do first conditions
        ]
    ]
    return test
]


Any pitfalls with this approach?  Also, any naming suggestions?  
I was thinking 'assert or 'assert-all.

Example:

assert [
    exists? %rebol.exe [make error! "rebol.exe does not exist"]
    0 < size? %rebol.exe [make error! "rebol.exe is empty"]
]

0 < (size? %rebol.exe)

I don't even have a feeling for assert

so, this is just case, with not in front of each condition?

so, why not just call it .. not-case ?

I guess it's to do with usage: though it functions like 'case, it 
is more like 'all with a step-by-step fallback.

Mmm.. yes, I've needed that kind of expression sometimes.

graham, the paren is not needed there.

chris: a trick i have seen:

if not all [
   msg: "rebol.exe does not exist"
   exists? %rebol.exe
   msg: "rebol.exe is empty"
   0 < size? %rebol.exe
] [make error! msg]

anyway, assert seems a good name to me.

Gabriele, yes I've used this trick, but it's a little uncomfortable.

Hi, syntax question: 

i want to insert a row into a mysql db:

string-block: [ "value1" "value2"
insert db [  "insert into table values (?,?)" string-block ]


this fails (string-block is not evaluated i guess), but i dont know 
how to generate the following

insert db [  "insert into table values (?,?)" "value1" "value2" ]

(which works) using rejoin, remold, join, .. whatever.

merrry christmas  :-)


insert db compose [  "insert into table values (?,?)" (string-block) 
]

and happy xmas to you! 


this works! how to factor out the "insert into .." string into a 
variable?

stmt: "insert into .."
insert db compose [ stmt (vals) ]

does not work, neither does 

insert db reduce [ stmt vals ]

which puzzles me ...

btw. is this the right place to ask?

this is the right place indeed  :-)

like so?

insert db reduce compose [ stmt (vals) ]
== ["insert into .."  "value1" "value2" ]

in REBOL since string datatypes evalutate to themselves, the result 
of the compose (which removes the outer block) will simply stay where 
they are .

I understand your issues trying to sort out all of the variations. 
 remember that most series handling functions return the series at 
some point (its head, its tail, or somewhere in between).

that becomes the starting point for the next function "in the chain"

most series handling functions modify the series "in place" instead 
of copying them.  This simplifies series manipulation by breaking 
down each step into little functions.

hm, but:

>> a

== ["abc" "def"]

>> compose [ "abc" (a) ]
== ["abc" "abc" "def"]

>> reduce [ "abc" a ]
== ["abc" ["abc" "def"]]


why is a block returned in reduce, but two strings (which i need) 
in compose. should be the same imho...

compose strips the outer block.

the block from (vals) ?

reduce simply evaluates each value in the block and inserts the result

i see

yep

this is not even mentioned in the tutorial i read... do more operators 
behave like that?

a common trick is to do this to unify a series as a block! which 
might also accept a string! :

val: compose [(val)]


this way, if val was originally a block, it stays that way, but if 
it was a string, its then inserted within one.  Note that the above 
actually creates a new block... so that the original val (if it was 
a block) and the new one are not the same

nope, its a special case for compose... and is one of its differentiating 
features.

also note that compose has a /deep refinement  which is very handy