World: r3wp

seems expensive to sort each element first

Cheaper than sorting it during each find.

intersect I guess

Sort the elements on insert and keep them sorted. Then sort the value 
you are comparing to before looking for it.

Thanks, Brian, for reformulating what I wrote above.

Ah yes :)

Interesting R3 "bug" btw:
>> intersect [[1 2] [3 4] [5 6]] [[4 3]]
** Script error: block! type is not allowed here

Works fine in R2.

There is a ticket for that.

very odd ... I changed to using blocks instead of sql, and the query 
increased from 1.7 s to 7 seconds!

I guess the sql indices are just faster than using a brute force 
search thru blocks

does a REBOL tar dearchiver exist? I can find an archiver in rebol.org, 
but not one the other way around.

Graham, you can do your own indices using hash!, but that might be 
pushing your complexity budget. Try it and see.

Henrik, just run the program backwards.
...... sorry.

Is there some function for switching two values in series? Ie. I 
have [1 2 3 4 5 6] and want to switch second and third element so 
result is [1 3 2 4 5 6].

reverse/part

I'm afraid this will not help very much if I want to switch second 
and fifth element.

MOVE

thanks!

:-)

Also SWAP.

SWAP is designed for just this situation, and has been backported 
to R2 as well. Here is the source if you have an old R2 version:
swap: func [
    "Swaps elements of a series. (Modifies)"
    series1 [series!]
    series2 [series!]
][
    unless any [empty? series1 empty? series2] [

        poke series1 1 also pick series2 1 poke series2 1 pick series1 1
    ]
    series1
]

SWAP is not mezanine, better!

In R3, true :)

Ah, sorry, I was looking for R3 sollution.

Note that the unless guard above is compatible with the R3 version. 
If either series is empty or at its tail at that position, it's a 
noop, silently.

So watch out.

Watch out for this limit in R3 too (which I forgot to backport):
>> swap a: "a" b: %b
** Script error: values must be of the same type
** Where: swap
** Near: swap a: "a" b: %b

I need it for blocks that has been sanitized before, so no problem 
here.

As far as I can tell, the single type restriction is so the implementation 
of the action in the various datatypes can be simplified. I am interested 
to see how well SWAP works for gobs though. Can you test this and 
see if there are bugs?

Yeah, I will. But I expect problems, gob! series support is very 
limited.

There shouldn't be any problems with this particular operation being 
defined, but I haven't done much bug testing since I don't need any 
graphics support most of the time. All I do is core.

As expected:

>> swap g next g
** Script error: cannot use swap on gob! value
** Where: swap
** Near: swap g next g

this IS core stuff. i haven't called view ;)

Does it work between different gobs? Note: It would only work with 
gobs that have subgobs, in theory.

If it doesn't, this needs a ticket. There are other similar gob bugs 
(CHANGE comes to mind).

Does it work between different gobs?

 - no, it doesn't work between two gobs and it doesn't work for one 
 gob (with sub gobs).

Then we need a ticket for that. I would think that there would be 
some GUI reasons for doing SWAP, though more for doing MOVE.

Well it' s a bad example, because
>> swap g next g
is easly performed with:
>> insert g g/2
:-)

??

>> g: [a b]
== [a b]
>> insert g g/2
== [a b]
>> g
== [b a b]

I just checked, and all of the functions called by MOVE are compatible 
with gobs. If they behave in a similar way then we can add gob support 
to MOVE.

working with gobs only

working with gobs only
 - isn't it a bug, then?

No it's a feature

A Gob can only have one parent at a time.

when you insert a gob already connected somewhere, it's automacly 
removed from the old place

Great feature

hmmm

Yes, I agree

Hm, I see that gob! now supports CHANGE and POKE, good news.