World: r3wp

(it throws error on expressions that retun unset like print .. because 
value- get's undef, but it can probably be made to work)

I think it should be perfectly possible

also.. something para-do could be made so that it would send code 
blocks to multiple rebol processes via tcp or pipes maybe and collect 
results back

it can do 1000 blocks with 5 expressions in 0.03s on my (little slower) 
comp , 10.000 in 0.25s , 100.000 in 3.75s ... so it seems stepping 
the blocks is not horribly slow, and I am sure my func could be made 
better

clearly, it could be faster but i'm not sure of the interest of such 
thing. If i want a small granularity in a process, i build tiny functions 
and push them in a to-do stack

I am also not yet sure how/if this could be usefull :), but as I 
said it's very impressive that you can do that (I have to go to sleep 
now)

I want to partition a block in place ,that is wohout copy.. 
e.g. 
blk: [ red green blue plum apple orange ]
partition  blk 3
>>  [ [red green blue] [ plum apple orange ] ]

without

while [not empty? blk] [
	blk: change/part blk copy/part blk span
]

Put that in a function.

thanks I have that

but I am interested in manageing without copy

Sorry, change/part -> change/part/only

if it is possible

ouch Brian, one second more and it was my reply :)

You have to copy - you are turning one series into three (in your 
example).

missing: span span

Right :)

unless [empty? blk: change/part blk copy/part blk span span]
(unless is a litlle faster than while)

just my 2 cents :)

Yes, but he wants it to repeat.

on large datasets a copyless repartitioning would be more efficent 
more like adding pointers to delimiters within the block

If you want it to speed up, use until.

argh, i meant until, not unless

grrrrrrrrrrr.....

Tomc, you can't do copyless and get subseries, but you can build 
a block of before and after references.

thanks steeve  that is about  what I am doing  but while[ not tail 
block ] [change...

brian yes that is what bugs me

if it was in a file  or an un loaded string I could insert  brackets 
to my hearts content . but not once i start useing it.

new: make blk 2 * divide length? blk span
while [not tail? blk] [
	new: insert/only insert/only blk blk: skip blk span
]
new: head new

Then use /part references.

uh !?

make blk -> make block!

not only that :)

The resluting block will be pairs of references to the beginning 
and end of his subseries. He can then get any subseries he needs 
by referencing it using the beginning and references with the /part 
option of COPY or INSERT, though using CHANGE or REMOVE will mess 
up the offsets of any subsequent references unless he is referring 
to a list! type.

a rose by any name ....  new and block both end up with the data 
so it is still copying

No, you are not inserting copies, you are inserting *references to 
the original*.

ok Brian, but still missing something, (insert/only new) :)

Yeah. I am actually working on something else right now, so errors 
are to be expected here.

Ahhh! I see  hmmm  I think all I will  need to do is reorder *between* 
references and subject those  sub-blocks 
 to further partitioning

The new block is really an index (in the database sense). You can 
sort and manipulate the index, then use the result to build a new 
version of the data if you like.

yep

the only thing you can't do is a mold or a form of this index :)

I'm backporting the last of the R3 reflection functions to R2 right 
now...

TYPES-OF - it's a nasty one to implement.

what are the costs when a (sub)block is reordered ?

skiped or sorted ?

both actually

You want to make all of your planned changes to the index, then build 
them all at once into new data.

Otherwise the positions get messed up.

skiping a block has no cost (no data modified), sorting has cost 
(data modified)

SORT with a custom compare function would be fast to use here.