World: r3wp

and the preprocessor can create a nice .catalog file for you

then, you can use a gui tool to edit .catalog files.

http://www.colellachiara.com/soft/libs/locale.r

Cool.  Thanks Gabriele.  I'll be relying on Ashley's RebGUI code 
for some of the
localization, but this looks like something to dig into.

A key consideration is whether you want the translation(s) to be 
static (compile-time) or dynamic (run-time). Advantages and disadvantages 
to both approaches.

Yeah, I toggle back and forth, but they'll be static this time.  
:)

some BIND expert, please, help me:

>> act: [add a b]
== [add a b]
>> for a 1 5 1 [for b 1 5 1 [do act]]
** Script Error: a has no value
** Where: do-body
** Near: add a b

There must be something easier than
>> for a 1 5 1 [for b 1 5 1 [do bind bind act 'a 'b]]

Is this simpler and the same effect?
    act: func [a b][add a b]
    for a 1 5 1 [for b 1 5 1 [act a b]]

hm, not exactly what I want because this is simplified, I have more 
variables than just 'a and 'b, but still useful.

May or may not work for your needs

for a 1 5 1 [for b 1 5 1 bind act 'a]

Is there an async https protocol in the offing?

mine works with both http and https

is this the current release?

or you own unreleased version?

same version as used on the detective and published on my site

Ok.

what would be the best way how to legalize urls like this one http://maps.google.com/mapfiles//cb/blue_outlines.png

I mean rebol-file from such a url

hm.. parse t: "a//bb/c" [any [to "/" p1: some "/" p2: (p1: change/part 
p1 "/" p2) :p1] to end] t

You mean, to "clean" it, into a legal url ?

http://anton.wildit.net.au/rebol/freezer/simple-clean-path.r

yes... that's what I wanted.. especially to make the local file secure 
as well... (so converting url to local file does not leave the send-box:)

I already had own version, but your is a little bit better as correctly 
handles complete url... my was only for the path

This is one reason I wrote my files:// protocol -- http://www.ross-gill.com/r/sandbox.html
(need to add to the library).

we also had a secure-clean-path....

Ah.. secure-clean-path should be in rebol.org already.

do func [a b /c] [either c [a + b][a * b]] 2 3

How do I invoke the refinement?

or perhaps:

f. func [a b /c] [either c [a + b][a * b]] 2 3

do :f 2 3 ; <--- here?

Think I figured it out...

nope, didn't work. I need the function in a composed block:


compose [do (:f/c) 2 3] ; causes error, since arguments are not inside 
the compose parantheses.

But the arguments are not used, so:

compose [do (:f/c 2 3)]


But now the arguments are local to the function. The arguments come 
from a different context, so I can't just compose the get-word'ed 
function with the arguments.


So I'll go back to the first question on how to make a refinement 
on an inline function?

why use the refinement in a throwaway function?

the function is rather complex and must be used many times, so I 
wrote it outside the block.

the block is a database query on a remote machine

and the function helps me to find out whether certain conditions 
for a database entry is true or false

Didn't Maarten use refinements in rugby?

hmm, since you're composing, why not put a path there?

otherwise... do 'f/c 2 3 should work.

>> f: func [a b /c] [either c [a + b][a * b]]
>> do 'f/c 2 3
== 5
>> do 'f 2 3
== 6

gabriele, what if the function is local, but must be used remotely 
(security is unimportant right now)

That is a good question, Henrik.

what is wrong with an extra assignment?
f:  func [a b /c] [either c [a + b][a * b]]]    f/c 1 2

do (f: func [a b /c] [either c [a + b][a * b]] 'f/c) 2 3

or a wrapper, an 'f-without-c and 'f-with-c.

volker, can't check right now if that works, but does it pack the 
entire function inside the block?

inside the parens

and then returns a path with a refinement. 'do gets the path, done.

You can put a 'use around it to avoid the temp

But not really sure what you want to do. somehow sending a function 
i guess.

well... if it's to be automatically called etc., i'd suggest avoiding 
refinements as much as possible. just use a logic arg.

if you really have to use refinements, you have to compose a path, 
no other way around in r2. (you see, that's why we've been asking 
for a low level apply native for so much time)