World: r3wp

If the types aren't the same the datatypes are compared, by the arbitrary 
ordering they have in the type list (the datatype number).

Henrik: it's the same as SORT

would it be possible to have more operators? In !Mikrotik group, 
I am trying do some stuff for MT routerOS API. Thanks to Anton, I 
can now proceed. When "studying" Python code, I found segment like:

elif l < 0x4000:
     l |= 0x8000


1) they can directly compare 'l of integer type to binary value. 
But I might make wrong conclusion here. But 'l is really result of 
len('string here') operation. But - even if so, I don't miss such 
an automation, as I can always write if l = to-integer #{8000}


2) Second line is more interesting - I did not find precisely |=, 
but found e.g. /= ... and it translates like do some operation, and 
assign. In this regard, the only comparable operator of REBOL is 
++ or --, but in R2 this is just mezzanine, in R3 native. But if 
I am right, their code:

l |=0x8000

R3:
l: (to-binary l) or #{8000}


So, if I would assume 'l being of correct type already (binary here), 
would it be possible to have?:

l |= #{8000}


Hmm, that is not probably compatible with REBOL parser and REBOL's 
assigment operator, which is :

If I am completly wrong, then please ignore me, I am not that much 
into the language design stuff :-) But why don't we at least have 
& for 'and, and | for 'or shortcuts?

What's the gain ?

Anyway, you can create your own alias.
In R3 >
|: :or
&: :and

In R2 >
alias 'and "&"
alias 'or "|"

you could use the same (R3 way) aliasing aproach in R2 too, no?

& and | are easy to add. The gain is to have apply & modify operation. 
Maybe there is no gain ... Simply instead of a = a + 10, you can 
write in python a += 10 in Python.

User-defined operators are planned for R3, but for now you have to 
use one of the existing operators, possibly renamed. If you can switch 
to prefix ordering you are less limited.

If R2 the built-in operators are special-cased in the DO function, 
so you can't do the renaming trick.

Is there any bits converter in REBOL? Or not even in rebol? I mean 
- how do I get from 255 or FF to "11111111"? :-)

In R3:
>> to-binary 255
== #{00000000000000FF}
>> enbase/base to-binary 255 2

== {0000000000000000000000000000000000000000000000000000000011111111}
>> enbase/base take/part/last to-binary 255 1 2
== "11111111"


The to-binary part gets more difficult in R2 because of the aforementioned 
bugs in the semantic model.

R2:
>> enbase/base #{FF} 2
== "11111111"

Steeve, the enbase isn't the problem in R2, it's the to-binary.

debase/base to-hex 255 16

To do proper integer to binary conversions in R2 you can convert 
the individual octets of the integer to char and then convert them 
to binary. I'm sure Steeve has more solutions for that though.

As he proved while I was waiting for the post to arrive :)

thanks .... will try to mess with it. The bug in R3 preventing to 
join binarries is really bad ...

I just mentioned it in the a98 call for fixes blog.

ok, thanks. Hopefully Carl notices it ....

I really hope we go through the CureCode tickets soon and collect 
all of the ones that make minor changes to core semantics, so we 
can do a rip-the-bandaid-off fix-them-all release soon. Before too 
much code is written that might depend on the unfixed behavior.

Not a98 though - we don't want to delay the new extension model.

it depends on Carl. I hope we get to more frequent R3 releases again. 
And - A98 will contain only partial Extension model implementation 
...

Yes, but enough to get the code into the hands of testers that can 
work out the kinks.

re:Python's operators. I've always liked AutoIT's assignment operators, 
some of which (especially concatenantion) would be quite useful in 
REBOL.

	=	Assignment. e.g. $var = 5ÊÊÊÊ (assigns the number 5 to $var)
	+=	Addition assignment. e.g. $var += 1 ÊÊÊ (adds 1 to $var)
	-=	Subtraction assignment.
	*=	Multiplication assignment.
	/=	Division assignment.

 &=	Concatenation assignment.Ê e.g. $var = "one", and then $var &= 
 10ÊÊÊ ($var now equals "one10")

Except for the concatenation, these are C language operators.

These make sense in C or Python syntax, or other languages where 
assignment is a syntax thing, but I'm not sure that it works that 
well with a language with word values, and assignment that doesn't 
use =. I don't see how they'd fit in REBOL syntax. That is not to 
say that the functions that these operators represent wouldn't be 
useful to have - just that they would fit in better in prefix form. 
Just an opinion though.

We have &= already though, it's called APPEND.

As long as the first argument is a series ...

All of the operators above are modifying, and the only things you 
can concatenate to in R3 are supported by APPEND. So yeah.

Series, or map or object.

is there a function which looks like find but return true here:

Type desktop to start the Viewtop.
>> a: ["111" "222" "111"]
== ["111" "222" "111"]
>> b: a/3
== "111"
>> same? find a b b
== false

otherwise this HAS to be added to R3

something like FIND/EXACT

or even better  FIND/SAME

it would also be a hell of a lot faster  :-D

no native of this kind is available yet AFAIK

or index? being extended, to return you a pointer to the originating 
series? But such information might not be available to interpreter 
after the assignment?

(but I wrote a corresponding function to the Identity articticle)

its a shame cause looping a large list manually and comparing with 
same?  is VERY slow  :-(

on a 10 million sized series. 


my fastest FIND-SAME loop is 20 time slower than FIND, which would 
be much faster, since all it would have to do is compare a pointer.

did you time it vs find?  maybe its faster than mine?

No way, I did not optimize for speed

can't you wrap the items of the list inside objects ?
In that case, it will be a find/same

here's my fastest one yet... I tried two so far...

	;-----------------
	;-     find-same()
	;-----------------
	find-same: func [
		series [block!]
		item [series! object!]
		/local s i
	][
		i: 1
		repeat s series [
			i: i + 1
			if same? s item [
				break
			]
		]
		unless i > length? series [
			at series i - 1
		]
	]
	

using until was slower probably because REPEAT is faster than UNTIL 
(no exit condition or series index to increase).

steeve no... its a database like flast list of labels with corresponding 
data items.

Hey it's your choice, nothing is unchangeable :-)

its for the list style... hehe would you rather do

fill my-list/aspects/list ["Steeve" 1 "Max" 2 "Lad" 3] 

or


fill my-list/aspects/list reduce [context [label: "Steeve" data: 
1] context [label: "Max" data: 2] context [label: "Lad" data: 3]]

note the multi-column list will use the same data interface


IMHO it gets even less fun if you are using DB queries to populate 
the list.


it also generates a lot of useless & SLOW binding everytime you change 
the list

How about combining find with a loop
find-same: func [
	series [block!]
	item [series! ]
	/local s 
][
	while [s: find series item] [
		if same? first s item [return  true]
		series: next s
	]
	false
]

that's a hell of good a idea  :-)