World: r3wp

even if done without aux data, it will still be MUCH faster to do 
in native.

No

But, as Ashley pointed out, if there's no need to keep the original 
order, it can be done in place easily

Lad, just looping without doing anything is slow in REBOL.

That does not prove your point

the average test is that things done in extensions are at least 10 
times faster, and Carl has shown a few examples which where 30 x 
faster.  really Lad, there is no comparison.

Still missing the argument

you can elaborate if you want... I'm just passing thru, in between 
two jobs in the renovations... will be back later.

To find out what is wrong, just write an "in place" version of Deduplicate 
in Rebol, divide the time needed to deduplicate a 300 element series 
by 30, and compare to the algorithm (in Rebol again) allowed to use 
auxiliary data.

You shall find out, that the fact, that the algorithm is native, 
does not help.

Or, to make it even easier, just use an "in place deduplicate" written 
in Rebol, divide the time to deduplicate a 300 element series by 
30, and compare to the time Unique takes (Unique uses aux data, i.e. 
a more efficient algorithm)

You shall find out, that the difference made by an inappropriate 
algorithm is so huge, that even as a native it would be too slow 
compared to an efficient algorithm written in Rebol

yes, I was not comparing two different algorithms... but the same 
algo done native vs interpreted.

I am curious who do you think would agree to write that nonsense

You talk about is so much that someone could write an extension in 
the same time and give a real prove:) What I can say, using additional 
serie is a big speed enancement. At least it was when I was doing 
colorizer.

You talk about is so much that someone could write an extension in 
the same time and give a real prove:) What I can say, using additional 
serie is a big speed enancement.

 - actually, it has been proven already, just look at the performance 
 of the UNIQUE, etc. functions

That is why I do not understand, why it is so hard to understand.

ALIAS function removed in the next version; see http://issue.cc/r3/1163
http://issue.cc/r3/1164http://issue.cc/r3/1165and http://issue.cc/r3/1835
for details. Also, http://issue.cc/r3/1212dismissed as unnecessary 
now.

R3 still uses case aliasing internally for word case insensitivity, 
but there is no other aliasing.

unfortunately, in the extensions, case insensitivity doesn't work.

(unless its been fixed in the very latest versions)

Do you mean in object contexts, or the words block?

Either way, report it.

word blocks for sure, didn't test on objects.

I will, next time I play on the hostkit.  right now I coudnt' provide 
example code which demonstrates it.

A report like "Words are not case insensitive in extension word blocks" 
would help a lot. Carl has been bug fixing lately, and that includes 
extension bugs.

ok... will add that to begin.

Please check if an object can be used by extension code to resolve 
the case aliases. I don't really see how they could if the words 
are translated to numbers at command call time, but that might be 
a limit of my imagination.

done.

That should help.

;-----------------
	;-     swap-values()
	;

 ; given two words, it will swap the values these words reference 
 or contain.
	;-----------------
	swap-values: func [
		'a 'b 
		/local c
	][c: get a set a get b set b  c]


>> a: 5
>> b: 1
>> if a > b [swap-values a b]
>> a
== 1
>> b
== 5


I've been using this to make sure inputs are properly ordered or 
ranges normalized when it matters further down in the code.

I have my own versions of the series comparison funcs Max proposed 
on 27-Jan. My versions of SHORTEST and LONGEST take a block of series 
values, and return the given item by length. I don't use them much, 
but there are times they are nice to have.

Every refinement with an optional value should accept also a none! 
(implied ?)
eg.
sum: func [
    "Return the sum of two numbers."
    arg1 [number!] "first number"
    arg2 [number!] "second number"
    /times "multiply the result"
    amount [number! none!] "how many times"
][	; test argument, NOT refinement
    either amount [arg1 + arg2 * amount][arg1 + arg2]
	; or if not amount [amount: 1] arg1 + arg2 * amount
	; or amount: any [amount 1] arg1 + arg2 * amount
]
so it would be possible to do:
summed: sum/times 1 2 (something) ;also if (something) is none

and obviously also:
summed: sum 1 2

instead of:
summed: either (something) [sum/time 1 2 (something)][sum 1 2]

apply :sum [a b (something) c]

Where is the multiplication?

>> foo: func [/bar x] [either bar [x] [99]]
>> apply :foo [(2 < 4) 123]
== 123
>> apply :foo [(5 < 4) 123]
== 99

Sorry but you are flying too high for me. I am tring to rewrite my 
sum function using aplly but do not understand how it could be done.

you don't rewrite sum, you rewrite your call of sum

The question is to have a simple method of calling whatever function 
which accpets an optional argument without rewriting the code that 
calls it evry time.

first, you can already pass none! as value to refinment arguments.

second, instead of your above
summed: either (something) [sum/time 1 2 (something)][sum 1 2]
just use:
t: (something)
summed: apply :sum [1 2 t t]

instead of my above
summed: either (something) [sum/time 1 2 (something)][sum 1 2]
I wish I could use
summed: sum/times 1 2 (something) ;also if (something) is none

for every Rebol function and also for my own functions preferably 
without explicitly add none! as a required type.

And how would you pass NONE as a refinement argument value?

if you have
amount: any [ amount 1 ]
you don't have to have the either

Marco, we use quite often code like:

>> foo: func[/something][
[     either something [ 1 ][ 2 ]
[    ]
>> foo
== 2
>> foo/something
== 1
>>

Also isn't it better to let the authors of the functions decide if 
the functions are able to accept none! or not?

And finally, in your case, why you must use the refinement, when 
you don't use it?

my-sum: func[
	arg1 [integer!]
	arg2 [integer!]
	amount [none! integer!]
][
	arg1 + arg2 * any [amount 1]
]
>> my-sum 1 2 3
== 9
>> my-sum 1 2 none
== 3

in the foo function /something is a refinement and not an _optional_ 
refinement. In your my-sum function amount is not a refinment and 
my-sum 1 2 none == 3 is correct. What I am saying is that the extra 
none! adds polymorphism (but i have not investigated that too much 
so i could be mistaken), so you can write: sum 1 2 or sum 1 2 3 or 
sum 1 2 none without checking for none before calling the function.

Ehm, the nature of refinements is that they're optional

And you can't write SUM 1 2 without a refinement if you have an extra 
AMOUNT parameter. The number of parameters is fixed in REBOL. The 
way to have optional parameters is to use refinements (or a BLOCK! 
argument)