World: r3wp

Did you try send/only ?

Has anybody built a binary diff/patch function set?

If I want to store some fairly big data as undo information, it seems 
to make sense to store it as a diff, and load the data that I want 
to undo/redo to. Then it would also be possible to store the entire 
changes sequence to disk.

binary diff can be expensive - if you control the application that 
modifies the data, can you log the changes instead?

if not, you probably want something like this: http://publications.cse.iitm.ac.in/734/

I did some a long time ago Henrik. It isn't fast enough to work on 
data of any size though. I can dig it out if you're interested. Can't 
remember what state of completion it's in.

Any *significant* size that is.

It's also high space complexity.

The biggest object here is around 4 MB or 550 kb compressed. I expect 
that binary diff would only be used during load and save, and then 
keep full objects in memory.

Mine will be way too slow for that.

My original goal was not binary diffs, but diffing blocks.

you are right. I looked into it and it looks to be way too slow, 
so I'm trying another approach.

>> negate 2 + - 2
== 0
>> - 2 + - 2
== -4

Bug?

Isn't unary minus introducing a third semantic rule? Functions are 
prefix, operators are infix with precedence over functions. And then 
unary minus is prefix with precedence similar to operators?

w> - (2 + (- 2))
== 0
w> (- 2) + (- 2)
== -4

Question is, how would we read
- 2 + - 2

It does correctly I think, here is the trace log:
>> - 2 + - 2
Trace:  - (word)
Trace:  2 (integer)
Infix:  op (add)
Trace:  - (word)
Trace:  2 (integer)

I'm asking, if unary minus should work as if being defined like this:

>> set '- :negate

no,  AFAICT the unary minus is applied exactly like all operator 
precedence (from left to right).


negate and  "-"  do not have the same precedence, as you noted, so 
its normal for:
    >> negate 2 + - 2    
and
    >> - 2 + - 2
to give different results.

Ok, intensional then. I'm surprised.

You shouldn't old pal :-)

Is unary minus the only prefix thing, that has same precedence as 
operators?

:) Sometimes I feel, I have no clue about this language. ;)

actually, unary minus has an higher precedence than other ops

Functions with literal arguments works about the same.

>> f: func ['a] [probe a]
>> f 2 + 2
2
== 4

So f gets the value 2 in this example.

Complicated rules! ;)

because functions with literals stop the evaluation flow

yeah

Tonight's Moment of REBOL Zen:

>> switch/default 'a [a 1] 2 
== 2

What's the insight here?

>> switch/default 'a [a [1]] 2
== 1

so what ?

Isn't it strange, that if the value being searched for (in this case 
a) is found, and the next item in the block isn't a block, then it 
fails to defaul?

No.

*default*

ok :)

From the docstring for SWITCH: "Selects a choice and evaluates the 
block that follows it."

>> switch 'a [a b [1]]
== 1
>> switch 'b [a b [1]]
== 1

must be a block, nothing else

Oh, the docs are different at
http://www.rebol.com/docs/words/wswitch.html
It sais "Selects a choice and evaluates what follows it."

Must be a block
 ... hm why?

because it says so

Ok, got it from Andreas' example. Multiple values. :)

C-style fallthrough.

(I think that was the intention behind that particular behaviour.)

yup, cute! :)

the syntax of switch evolved

it was different back...

Damn, now I have to change my own switch. ;)

Yes, I think back in 2.5 (or earlier), switch 'a [a 1] actually returned 
1.

Ah, that was still the case in 2.6, even.

I'm behind schedule, since I haven't noticed this.