World: r3wp

It also makes the "immediate values aren't modifiable" argument a 
little more iffy.

But the differences are real, that is like putting our head into 
the sand pretending there is no danger nearby

{It also makes the "immediate values aren't modifiable" argument 
a little more iffy.} - I do not use the notion of "immediate values", 
neverheless, it does not, I would say

(the NEW-LINE attribute is immutable)

It's mutable with the NEW-LINE function :)

No, see my article

It is exactly as mutable as the sign of an integer is, when using 
the Negate function

(not at all)

Immediate values are a bit iffy concept in REBOL anyways, so it's 
probably for the best that you don't use the notion. Nonetheless, 
there is a documentary typeset in R3 called immediate!, which includes 
the values that are fully stored within a value slot, rather than 
referencing memory elsewhere.

That is what I meant by "immediate values".

Let's move this to !REBOL3, shall we.

Naw, let's let it go :)

Strangely enough, while there is no obvious operator for EQUIV?, 
we could use === for STRICT-EQUIV? and !=== for STRICT-NOT-EQUIV?.

EQUIV?   could be   ~
 its the actual math symbol for it.

http://en.wikipedia.org/wiki/Table_of_mathematical_symbols

This would solve the operator problem for developers who understand 
the limits of IEEE754, and still let regular developers expect 0.3 
to equal 0.1 + 0.1 + 0.1.

EQUIV? is more strict than EQUAL?, so it would go the other way around.

We considered ~= in the last round, but that would be even more approximate 
than =, so the hierarchy doesn't work unless ~= means EQUAL?.

Remove ALIAS: http://issue.cc/r3/1835. Thanks, Andreas, for discovering 
the absence of this ticket.

proposal for four very usefull series functions....

shorter?: func [a [series!] b [series!]][
	lesser? length? a length? b
]

longer?: func [a [series!] b [series!]][
	greater? length? a length? b
]

sortest: func [a [series!] b [series!]] [
	either shorter? a b  [a][b]
]

longest: func [a [series!] b [series!]] [
	either longer? a b  [a][b]
]

sortest == shortest

Is that so ?

huh?

I mean, usefullness

I'm thinking, what kind of code is it that one writes, when you have 
to compare series lengths?

I just used it 10 minutes ago again... checking if two series need 
to be synchronised.

(though they don't use the same values, they are interdependent)

we could also add EQUAL-LENGTH? just for completeness

ok

they could just be part of a delayed load series module.  there are 
many missing series handling/probing functions in REBOL.  we end 
up writing them over and over.

remove-duplicates, extract-duplicates, remove-same, prefix?, suffix?, 
etc   the list is long.

how does remove-duplicates work?

like unique?

this implementation is order safe, removing the duplicates from the 
end rather than those in the begining

remove-duplicates: func [
	series
	/local dup item
][
	until [
		item: first series
		if dup: find next series item [remove dup]
		tail? series: next series
	]
	series
]

remove-duplicates, does it in-place

prefix? and suffix? just return true if a series starts with the 
same items in the same order as the second one.  
the second argument is the prefix to compare

so you can easily do:

unless suffix? file-name %.png [append file-name %.png]

the reason these are usefull is that when you chain them within other 
series handlers, you don't need to always add darn ( ) around the 
operators.

so what's the difference between unique and remove-duplicates ?

unique returns a new series.

like all  "set"  handling functions.  (exclude, extract, etc)

I rarely need unique... I often need remove-duplicates.

yeah, it's shame that unique make a new serie.

I was just curious, because even with new series unique is much faster.

faster, but not GC safe

its a shame that all "set" functions make new series.  we could just 
easily copy before calling unique:
new: unique copy serie

Agreed 100%

though there is a lot of memory overhead for large series, I'd rather 
have a refinement on all sets probably   /only  or something similar, 
to have them work "in-place"


come to think about it, maybe we could make a CC wish for this, seems 
like its been a topic of discussion for years, and pretty much eveyone 
agrees that both versions are usefull.

SWAP is another interesting one... takes two series and swaps their 
content, in-place.

I don't see your point with SWAP

INTERLEAVE is a very usefull function, using two series and mixing 
them up with many options like counts, skip, duplicates, all cooperating.

SWAP is interesting, though not as usefull... I don't remember when 
I used it.  ;-0