World: r3wp

The trick of course is that modification of the INSERT and APPEND 
variety can result in reallocating the block, and native code wouldn't 
necessarily notice the change since it would still be referring to 
the old version. It's not quite the same thing with REMOVE and CHANGE 
style modifications.

In R3:
>> while b: [change back tail b false true] [1]
== none
>> while b: [remove back tail b false true] [1]
== none
>> while b: [false true] [print 1 remove back tail b]
1
== []
>> while b: [true] [print 1 append b false]
1
== [true false]
>> while b: [append b false true] [print 1]
== none
>> while b: [append/dup b false 1000 true] [print 1]
== none


Clearly modifications seem to work in R3, at least to the tail (which 
is the portion of the block that would affect the result), even if 
a realloc is necessary.

Your code made inserts at the beginning of the code block, which 
wouldn't affect the result since it is only the last expression that 
matters in the cond block (except for side effects).

>> 1 ** 2
== 1.0
>> help **
USAGE:
    number ** exponent

DESCRIPTION:
     Returns the first number raised to the second number.
     ** is an op value.

ARGUMENTS:
     number -- (Type: number)
     exponent -- (Type: number)
>>

what's the justification of returning a decimal value?

for retu..

I guess I should just use shift/left instead of '**

** uses a decimal operation, so if it didn't return a decimal it 
would have conversion losses. For powers of 2 SHIFT is better.

I was thinking of powers of integers so that makes sense

Mean WHILE.....Thanks for debugging my example, Brian. I got confused 
and reported the wrong thing.


Yes -- on R3 if is possible to modify the cond-block and that modification 
will be respected. That''s how I hoped it would be.


It is not possible to _replace_ the cond-block by reassigning its 
word. But that's understandable and probably exactly what we'd all 
want:

   cb: [true cb: [n < 3] true]       ;; cond-block that overwrites itself
    n: 0

    while cb [n: n + 1 print [n cb]]   ;; WHILE that uses original cond-block

Re: ";; cond-block that overwrites itself" I am having trouble with 
this formulation, since it is not true; the block (when evaluated), 
just changes what the CB variable refers to, but surely does not 
everwrite itself.

err: 'cb and overwrite

we need to make distinction between overwriting a variable, and overwriting 
a block

Sunanda should know better.

Perhaps WHILE could also accept a word! for its condition parameter, 
and when it does, evaluates it to the block it is expected to reference 
before continuing to evaluate as usual.
Eg.
	while 'cb [...]

That functionality is pretty easy to by evaluating the word inside 
the condition block yourself.
eg.
	while [do cb] [...]

so I don't think it's really necessary.

What should this function be called, and what options does it need?

change-in: funct [key value] [
    either a: find block key [change next a :value][
        repend block [key :value]
    ]
]


It basically implements the a/key: value operation of maps, but for 
series.

Andrew Martin chose ASSOCIATE for that sort of thing:
   http://www.rebol.org/view-script.r?script=associate.r

SQL calls it MERGE, because UPDATE was taken.

I suppose you had FUNCT [BLOCK KEY VALUE] in mind for the above, 
Brian? If so, I think I like MERGE much, but every now and then someone 
has to suggest ALTER

I vote for UPDATE. It should be able to handle more than ports, even 
if the behavior isn't exactly the same.

Yes, of course, Gregg, UPDATE only working on ports seems indeed 
too limited for such a nice word. 


BTW, Brian, is the above behaviour to return after the change for 
updates and at the insertion for inserts intended?

>> update: :change-in
>> attributes: []
== []
>> update attributes 'color red
== [color 255.0.0]
>> update attributes 'color blue
== [] ; or rather [color 0.0.255]

its the natural completement to SELECT, so UPDATE is quite natural.

On the other side, to answer your question, it's related to SELECT 
and should probably support most, if not all, of SELECT's refinements, 
too. That's a bit of a stretch, because for ports UPDATE probably 
needs to be very fast and can't be thwarted by too complicated refinement 
handling?

Ah, Max, you're first ;-)

hehe

UPSERT

Widely used term (in database circles) for this operation.

I wasn't the original author, but I'm willing to bet that the return 
value wasn't considered. The best behavior would be to return the 
head.

Same for the [block yey value] thing :)

Andreas, the recent SQL standards call this operation MERGE, partly 
because UPSERT sounds terrible.

Can anyone suggest a free tool that can be used to decrypt files 
that have been encrypted using Rebol's Rijndael using a 128 bit key?

And not Rebol!

ie. I want to be sure that if I send a file encrypted using AES, 
that someone can decrypt it.

Try here: http://www.movable-type.co.uk/scripts/aes.html

or this http://people.eku.edu/styere/Encrypt/JS-AES.html

those only encrypt/decrypt text .. looking for a file tool

via Google http://www.aescrypt.com/

-1 for UPSERT.

aescrypt looks good .. now to see if it can read a file encrypted 
by Rebol

Hmm ... http://www.rebol.org/view-script.r?script=crypt.r


I changed the strength to 256, and algorithm to rijndael .. and encrypted 
a file, but get an out of memory when I try to decrypt it :(

the other issue is that Carl uses checksum/secure to turn the passphrase 
into a binary encryption so tricky to get another tool to decrypt 
using that binary key

checksum/secure is a SHA-1 hash.....Hashes are not decryptable, but 
you should find other tools that can produce a SHA-1 hash.

the difficulty is pasting the binary as input to the fields used 
by programs such as aescrypt

I'm not even sure that the encryption needs a binary encryption key

encryption port needs ...

Well, I used the encryption key as a string instead and encrypted 
to 256 bits using Rijndael and successfully decrypted with Rebol. 
 But aescrypt was not able to decrypt the file :(

I had padding set to false

If you have counters block and want to increment it, is there some 
better solution than this one?
	b: ["a" 1 "b" 1]
	change f: find/tail b "a" f/1 + 1
	probe b

don't know if any of these are better(and in which sense better):

change n: next find b "b" n/1 + 1

b/("a"): b/("a")  + 1
...

This does it without using a temporary word....and it should work 
even if the counter name is not amenable to Cyphre's path notation 
(ie you are using something more exotic that strings for counter 
ids, or are using an older version of /Core).
   b:  next find/skip head b "a" 2 b b/1: b/1 + 1
Just remember to reset ....
   b: head b
....once in a while:)