World: r3wp

:/)

this may look more readable:

; implementation:
swap-n: func [
	{swap n elements}
	a [series!]
	b [series!]
	n [integer!]
][
	loop n [swap-first a b a: next a b: next b]
]

swap-sub: func [
	{swap the subseries using the SWAP-FIRST function}
	a [series!]
	b [integer!]
	/local la lb pa pb
][
	pa: a
	la: b - 1
	pb: skip a la
	lb: (length? a) - la
	while [all [la > 0 lb > 0]][
		either la <= lb [
			swap-n pa pb la
			pb: skip pa la
			lb: lb - la
		][
			pa: skip pa la - lb
			swap-n pa pb lb
			pa: skip pa negate la
			la: la - lb
			pb: skip pa la
		]
	]
	a
]

aha, it is wrong, this way

swap-sub: func [
	{swap the subseries using the SWAP-FIRST function}
	a [series!]
	b [integer!]
	/local la lb pa pb
][
	pa: a
	la: b - 1
	pb: skip a la
	lb: (length? a) - la
	while [all [la > 0 lb > 0]][
		either la <= lb [
			swap-n pa pb la
			pa: pb
			pb: skip pa la
			lb: lb - la
		][
			swap-n skip pa la - lb pb lb
			la: la - lb
			pb: skip pa la
		]
	]
	a
]

swap-first: func [
	{swap the first elements of A and B}
	a [series!]
	b [series!]
	/local t
][
	k: k + 1
	set/any 't first a
	change/only a first b
	change/only b get/any 't
]

k: 0
swap-sub [1 2 3 4 5 6 7 8 9] 7
k ; == 6

So, Sunanda, how many swaps you are getting?

If the two series lengths are L1 and L2, I get L1+L2-1 swaps -- at 
most. But there are exceptions, eg:
    [a b c d   1 2]

Needs only 4 swaps....An any [{L1 // L2) = 0 (L2 // L1) = 0] test 
triggers a shortcut.


However .....I also have some edge-case bugs in my code -- so you 
win!!

/9c=8O%%%%%%%%%%%%%%%%%%%%0P/*****5%('rrrrrrrrbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

OUPS my cat on my keyboard ;-)

:-)

Claude, use the little pencil above the typing area for multi-line 
text. That might reduce accidental sending :-)

Thanks for your hard work.
I didn't read your proposals yet, though.

I think I found the optimal way. As you noticed, it involves modulo 
maths.

swap-sub: func [s pos /local len e sav][
	-- pos
	sav: s
	forever [
		e: skip s pos
		len: length? s
		loop len - pos [swap ++ s ++ e]
		if zero? len // pos [break]
		pos: pos - (len // pos)
	]
	sav
]

Now I will rewrite it, with different input parameters, so that it 
can swap sup-parts of larger series.

That looks good steeve -- short, neat code, looks optimal on the 
swap numbers.
And a completely different algorithm to mine.

The swap numbers may be optimal, but it appears to me than the code 
may be faster.

if one swap the ++ operator with --  in some cases, then one may 
reduce the number of forever loops needed.
But the swap number ober the serie will remain the same.

How to waste his time ? Get ladislav's mergesort working in-place.
--> done

Is it faster that way?

Slower, the algorithm more complex, lot of swap.
If it was compiled, maybe...

I wonder, whether the majority of users prefer POKE to stay as-is, 
or would welcome it to accept any-type DATA argument?

I don't use POKE.. what I remeber.. maybe just in some rare cases.

Steeve, good fun. I came to a swap-sub using modulo as well, but 
it only worked for some series lengths, and I had to sleep before 
figuring out which lengths they were, but they surely included prime 
numbers.

(I used only a single loop). I thought maybe I could detect which 
series lengths could be processed using only a single loop, and other 
cases could be processed using another algorithm.

Steeve, did you finish the swap-sub yet? Curious.

It was already, I just changed the inputs for other purposes.

You said above "so that it can swap sub-parts of larger series". 
Is that what you mean?

yeah, i just had to pass an extra parameter to set the length of 
the added sub-parts, instead of calculate it.
But the algorithm remains the same.

Ok, easy.

Ladislav, does not POKE DATA parameter already accept argument of 
any type ?  ( I checked only Rebol3 alpha 76 (not most recent) and 
Rebol2.7.7).

Steeve, 

What might be interesting (and possibly even ... useful) is to generalise 
to be able to swap (rotate) any number of sub-series, eg.
for three sub-series in a series [... AAA ... BBBB ... CC ...]
AAA moves to where BBBB is currently,
BBBB moves to where CC is currently, and finally
CC moves to where AAA is currently.

(but not tonight, for me..)

Should not be that hard with a recursive approach

(I did not say that I will do it)

REBOL 3.0 A110 2-Nov-2010/3:56:20

>> source poke
poke: make action! [[

    {Returns value after changing its data at the given index. (Modifies)}
    value [series! port! map! gob! bitset!]
    index {Index offset, symbol, or other value to use as index}
    data "New value"
]]
>> poke [1] 1 #[unset!]
** Script error: poke does not allow unset! for its data argument

So, I was curious, what the user preferences are. Current poll state:


any-type! DATA : any DATA = 1:0 (counting just myself, no other response 
obtained)

Normally I would like to limit the occasions where an unset! can 
get through without errors triggered (those errors are the whole 
point to the unset! type), but in this case the other series manipulation 
functions accept any-type!, so consistency wins here. +1 any-type!.

anyone did anything with Rebol and JVM (Java) integr/cooper-ation. 
I need functionality of some big java lib ("server side") in rebol. 
What would you do or use?

add a port to communicate with the java app?

Ladislav, oh I see. Yep, +1 any-type!

Steeve, would need to convert to iterative to stay memory safe.

>> blk: copy [1]
== [1]
>> blk/1: #[unset!]
** Script error: blk/1: needs a value
>> poke blk 1 #[unset!]
** Script error: poke does not allow unset! for its data argument
>> head insert blk #[unset!]
== [unset! 1]

What other series funcs are you think of Brian?

If any-type! is allowed, should the behavior be like INSERT?

I'm not saying it's a useless requirement, but what is purpose to 
have #[unset!] in a serie, instead of anything else working, for 
instance, #[none!].
Just asking...

(#[none], not #[none!])

I was thinking of APPEND and CHANGE too - they both also allow any-type!.

what is purpose to have #[unset!] in a serie

 - well, it was not me who 'introduced' #[unset!] to Rebol series.

Steeve, triggering an error is the point of unset!. The none! type 
is for when non-values aren't an error.

nevertheless, since:


change at [1 2 3] 2 #[unset!] works, my opinion is, that poke [1 
2 3] 2 #[unset!] should work as well

In my opinion, there are certain simple and useful states, that we 
can choose from. One of the states might be, that #[unset!] is not 
a Rebol value at all. That approach was chosen for the #[end!] value 
as far as I can tell. Moreover, that approach was chosen even for 
#[unset!] for R1, but, for some reason, Carl declined from it, choosing 
a different approach.

So, instead of the R1 approach, Carl 'introduced' #[unset!] into:

*results of Rebol expressions
*values you can set Rebol words to using SET/ANY
*values you can "store" to and "retrieve" from Rebol series

, etc.

In my opinion, to 'allow' INSERT, APPEND and CHANGE handle #[unset!] 
makes 'disallowing' POKE to do the same uncomfortable.

That is why allowing it for POKE is a good idea.

This came up in a CC ticket for another series function once, and 
the reasons for the choice made there apply here as well. There are 
two main reasons that you would want series functions to be able 
to handle unset!:

- This gives the error context, so when it is triggered you can get 
an idea of what the conditions were that caused it.

- Your code might be structured to handle errors on output from the 
series instead of input to it.