World: r3wp

petr: i think the answer is yes, but i don't remember. i'm not sure 
it has ever been tested though.

graham, what kind of testing help do you need ?  I am going to try 
the script

Just to check it works for a start!  :)

I only got this script to work once .. never again after that!  but 
it works using standard smtp port on other servers.

There's some type of deadlock occuring .... waiting for gmail's smtp 
server to respond to the insert smtp "."

Now, if you  change insert smtp "." with insert smtp "^M^J.^M^J" 
gmail drops the connection

.

I think, it's a shame, that cannot do this:
>> test: func[/a a][probe a]
** Script Error: Duplicate function value: a
** Where: throw-on-error
** Near: func [/a a] [probe a]

as I need so often to write something and have the name same as the 
path :(

yes, that is the limitation - you try to find out intuitive name 
for your function's refinement, but then you want to use intuitive 
names for your words. So I sometimes used underscore for words, but 
it looks ugly ...

One hack is to assign the refinement value to the refinement word 
at the start of the function:
test: func[/a _a][if not none? a [a: :_a] probe a]
You can then just refer to a.

It introduces an ambiguity though -- does none mean no /a refinement 
supplied, or that the value was none ?

in useage after all these years  I've come to realize that verifying 
the refinement itself is less usefull than ingnoring the value if 
its none.  one should usually use none as the fact its not a value, 
so therefor just like a default, or something to ignore.


this kind of useage allows one to rethrow  the function (is that 
the proper term?) with very little fuss.  in a way, this becomes 
exactly like option args in other applications,  ex:

myfunc [count /option opt][
	unless (count: count - 1) = 0 [
		if opt [
			print count
		]
		myfunc/option count opt
	]
]

many people say that rebol is mem hungry... I can say that today 
I was proven otherwise in some way.

a 10MB xml file loaded from the net and loaded with xml2rebxml  took 
about 100mb of ram.  the same file loaded in firefox  took up 600mb 
of ram.  I was pretty shocked !

10mb of string becomes 600MB of binary xml objects... this is just 
insane.

Maxim, "rethrow": I would say "recursing into" myfunc or maybe "re-calling" 
myfunc. "Rethrow" is more for error handling.

... error handling or "quick exit" flow control.

that's what I was wondering... somehow rethrow sounded cooler  ;-)

juggling?

I have question WRT to error handling:

If I use

make error! "problem"

Immediatly an error message is printed to console. How can I catch 
this? I just want to return an error that I can catch an DISARM to 
get an error-object. Without anything printed to the console.

Wrap the target code in an attempt:

   attempt [oops: make error! "problem"]
   if error? oops [probe disarm oops]

ah, I tried it with TRY etc.

The MAKE error stuff is return from a function.

For example I call:
	a-function 1


and if this function has an error, it calls an error-function that 
ends with: make error! ...

I can't do: attempt [a: a-function] to getback the error.

This works for me:
a-function: func [] [make error! "problem"]
error? a: try [a-function]
***

If that's not quite what you have in mind, take a look at 'throw 
and 'catch -- they may be more suited.

Ok, is this error than gone? It looks like within the error-object/near 
there is an other error. So I can handle the first one but as soon 
as I do something, I get the next output...

Ah, damn, there was an other error in the code...

Happens to me all the time......:-(

Robert: the following approach is better:

a-function: func [] [return make error! "problem"]

error? a-function ; == true

or: error? the-error: a-function

etc.

I want to create a little spreadsheet application where users have 
access to the mathematical functions in rebol and nothing else.

Is there some way to constrain 'do to work within a specific context 
of some mathematical functions, and nothing else?

Or, do I have to write a little mini parser ?

There's a little parser here http://www.rebol.com/docs/core23/rebolcore-15.html

you don't have to write a parser. The approach using my SAFE-EVAL 
function may be faster:

safe-eval: func [
	stm-block [block!]
	/local stm
] [
	stm: make block! (length? stm-block) * 2 + 1
	insert stm first stm-block
	while [stm-block: next stm-block not tail? stm-block] [
		insert tail stm :first
		insert/only tail stm stm-block
	]
	first do/next stm
]

(before using SAFE-EVAL you should test the first element of the 
STM-BLOCK to find out whether it is one of the functions you are 
willing to evaluate)

so, use example?

Do I have to check each value in the block for safety?

error? try [safe-eval [square-root print "gotcha!"]] ; == true

...check each value in the block for safety?
 - no

just the first one

Ok, I'm going to use this example first : 0.56 * sqrt(tender28) + 
0.28 * sqrt(swollen28) + 0.70 * ln(ESR) + 0.014 * GH

turn that into Rebol first ... and then only check the first value?