World: r3wp

can I ask what does it mean "except for bindings" ? you mean like 
native code libs (bindings) .. or binding in rebol sense which I 
heard about, but don't fully understand what it means

He means rebol bindings. This is a good read on bindings: http://www.fm.tul.cz/~ladislav/rebol/contexts.html

where is Ladislav? buuuu 8(

Henrik, thanks I will read it

Was CHMOD ever implemented for the FTP scheme in REBOL 2?

I don't think so, no.

That is, it was never built in. Somebody might've hacked it in for 
their particular situation.

ok, thanks

This is continued from the talk we had with BrianH in the R3 group.. 
but it's R2 code so  (about do/next)

paralel doer:

para-do: func [ codes- /local codes cnt values code- value- all-done 
] [
  codes: copy codes-
	cnt: length? codes
  values: make block! cnt
	loop cnt [ append values none ]
	until [ 
		all-done: true
		repeat idx cnt [
			code: pick codes idx
			if not empty? code [
				set/any [ value- code- ] do/next code
				codes/:idx: code-
				values/:idx: value-
				all-done: false
				print mold value-
			]
		] all-done
	] 
	values
]

usage example: 

>> codes: [ [ a: 12 + 23 b: a + 100 c: b * a ] [ t: join "aaa" join 
"bbb" "ccc" find t "b"  ] ] 
>> para-do codes
35
aaabbbccc
135
bbbccc
4725
== [4725 "bbbccc"]
(it collects results of all blocks when done and returns them)

I wonder if we can do MAP-REDUCE in REBOL :)

(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.