World: r3wp

volker: i think that rule always applies if you want to be safe. 
you never know what someone could be doing to work around your safety; 
more checks means safer.

anyone know what the 'run function does?  I always get a message 
that its not available in this version of rebol but I am using sdk 
so not sure why.

In Command:
>> help run
USAGE:
    RUN file /as suffix
DESCRIPTION:
     Runs the system application associated with a file.
     RUN is a native value.
ARGUMENTS:

     file -- The file to open (file, URL) or command to run (string). 
     (Type: file url string)
REFINEMENTS:
     /as
         suffix -- (Type: string file)

Though having just tried it......it didn't work either.
Looks like an older name for call

it's not.

run will call a native application to open the file in question eg. 
acrobat reader for pdf files.

It is only enabled on IOS .. I have asked RT why it can't be enabled 
for the sdk as well.

Yes Graham that is what it looks like to me as well - looks similiar 
to a winshellexecute function.  Would be good for them to activate 
it as that would be a very good function to have.

And, perhaps even REBOL View too eh?

Ahhh not complaint here Carl.

Is this OK? And if yes, then why?

>> x: context [d: does [print e]]
>> y: make x [e: 1]
>> y/e
== 1
>> y/d
** Script Error: e has no value
** Where: d
** Near: print e

yes, this is OK

and why?

because you refer to word 'e with global context

>>  x: context [d: does [print self/e]]
>>  y: make x [e: 1]
>> y/d
1

ok I see

In this case it would work:
>> x: context [e: 5 d: does [print e]]
>> y: make x [e: 1]
>> y/d
1

because the 'e in function d would be bound to the context of the 
object (self)

yes I know, I needed it when extending objects

so I'll use 'self or define everything in advance

If you use 'self you are safe rearding contexts IMO.

if you want to extend context, you might want to try associative 
array instead

or a "dynamic" object like o: make object! [data: make object! [x: 
1]]

usage:

>> o/data/x
== 1
>> o/data: make o/data [y: 5]
>> o/data/x
== 1
>> o/data/y
== 5

.

Q1: I want to replace all 'none in a block with _different_ empty 
strings, what's the fastest way to do this?

(replace/all BLOCK none ""       replaces all 'none with the same 
empty string)

Q2: I have to blocks containing strings, and want to find out which 
of these strings differ (I need all differing positions), what do 
you think is the fastest way to achieve this?

Thanks in advance for all ideas!

PS. Do you, like me, feel that the replace way of doing things is 
questionable?

b: ["s1" "s2" "s3" "s1"]
parse b[any[to "s1" p: (p/1: copy "t0") skip]]
? b

Q2 again: Sorry, my axplanaition was a little unclear: 

I have a row from a database, and store away one block, and display 
the other for the user. The user may, or may not, change the data.
>> orig: ["Mr" "Petr" "Ustinov"]
>> data: ["Sir" "Peter" "Ustinov"]
>> magic-changed-func orig data
== [1 2]

orig: ["Mr" "Petr" "Ustinov"]
data: ["Sir" "Peter" "Ustinov"]
; same length !
out: copy[]
repeat i length? orig [ 
	if orig/:i <> data/:i [
		append out i
	]
] 
? out

Q1:use [x] [

Sorry

Q1:
use [x] [
    x: block
    while [x: find x none!] [change x copy ""]
]

Ingo, I have similar feelings too sometimes. I need a higher level 
function to do some things like that, but it's not there....

I often wanted reduce and compose to not make a copy for you, but 
work directly on the block. (Perhaps new functions "induce" and "impose" 
?)

induce should be fairly easy -- walk the block with 'for and 'poke 
back the value

blk: [a b c] 
format: [(1 + 2) (random 100) c]

impose: func [blk format][repeat n length? format [if paren? format/:n 
[poke blk n do format/:n]]]
impose blk format
;blk == [3 95 c]

For induce I think I would use do/next.

induce: func [blk format][change blk reduce format]  ; (except, as 
a native!, without creating a temporary block)
induce blk [1 + 2 random 100 'c]
; == [3 67 c]

Hi Voker, BrianH, thanks for your ideas ... they look mighty long 
compared to normal Rebol code ;-)

Sorry, I wanted to type Volker, of course!

; Q1: copy/deep will give you new strings:
block: [none none none]
new-block: copy/deep replace/all block 'none {}

; Q1 Or if you know you can reduce it you could do something obtuse 
like:
block: ["a" none "b" none none]
use [none][none: does [copy {}] bind block 'none]
reduce block

But if you do need to do an actual replace on the original block 
- see the other solutions :-)

Hi Brett, your first version looks pretty good ... now I'll have 
to dig out my little profiler, and see what's the fastest of all 
of these ;-)

I reckon the parse will win.

Brett's is the nicest looking though.

Brett, your obtuse way will only work if you are replacing 'none 
(as a word), but not none! values.

eg. reduce your input block:
	block: reduce ["a" none "b" none none]