World: r3wp

(no chance some of you change a bit his color : you look the same 
all three)

Volker, the typecheck can be done by the programmer, or a type inferencer, 
either way statically. When rebcode gets a JIT those typechecks get 
put right back to implement generic math, because the real machine 
won't have it.

if i want a generic sum, people feed [ 1 2.5 3 ], it would be faster 
in rebcode, so makes sense. with hand-typecheck it would be slower. 
I guess its to rare to worry about, but i would keep the option.

but main reason is, its easier to remember, set seti setd add addi 
addd would be first thoughts.

When you hand-typecheck, you usually do it at programming time, not 
runtime, so it's not so bad.

(I just read the names :)

i write support for rebol, and so it should be easy to pass data.

Didec: on linux we cannot change colors

Ah, didn't know that. Pooor guy ;-)

it worked, see dotgroup.

I get an error report requester to send feedback to safeworlds

ahhh but it did change

(I'm just lazy)

We managed to give you a different color than us. :)

but then ...  "Multiple Errors, Altme must quit now"    <blink>

If change is done to add the "i" on add and others, it will also 
be the case on comparison operators.
eqi, gti, ...

I was hoping so.

Did you see that idea in Rebol Enhancements about picki and pokei 
for bytewise access to integers?

I get generic add by doing this:
    to-dec a
    to-dec b
    addd a b

You can skip one or both conversions if you can trace the type flow 
and be sure of the data types of the arguments.

agreed, thtat is sufficient.

Sorry, to-dec a a ...

Your opinion is require.


Some opcodes exist in double due to specific integer or decimal value 
handling.

What would be your preference on opcode naming ?

Choice are :

1) INTEGER add mul div min eq gt gte ... / DECIMAL addd muld divd 
mind eqd gtd gted ...

2) INTEGER addi muli divi mini eqi gti gtei ... / DECIMAL addd muld 
divd mind eqd gtd gted ...

3) INTEGER add.i mul.i div.i min.i eq.i gt.i gte.i ... / DECIMAL 
add.d mul.d div.d min.d eq.d gt.d gte.d ...

(Today rebcode is 1)

It concern math, logic and comparison opcode.

be brief. use the first one like now

I prefer the second, although the third has merits.

The second is brief and consistent. The first is just brief, half 
the time, and confusing.

3 is not rebol. add/i add/d if you really want that. the little extra 
letter works best for me.

as in 2)

The third makes the typing distinct from the opcode, and that could 
be an advantage when future opcodes are added later.

2

For instance, if you had set.i mean set integer, seti.i could mean 
set integer indirectly.

if we go that complex, i go for extra field or pathes. for now rebcode 
is confusing enough, then at least the keywordsshould be easy.

3) come from asm68k that looks like that.

And rebcode, as a byte-code, is near ASM (even if more powerfull, 
ie: block!)

Paths are much bigger to store, meaning memory and lookup overhead. 
They are blocks you know, with different syntax.

dot looks like a space and spaces are veryimportant in rebol-layout. 
i would not use that.

A period looks like a space?

I know also that performance depends on needed volume. both processing 
steps and codeamount are small.

looks close to it. its very small.

You can change path opcodes to dots with rewrite rules if you prefer. 
Opcodes are supposed to be static. The whole interpreter would have 
to be changed to make opcodes paths, and it would be much slower 
after the change.

in rebol most signs fill the space  if .. [ ..], not  if .. { .. 
}. a-word, not a_word. i like that

Maybe 2 or 3 times slower.

sure, but i can change the other way. why start with a bad opcode 
and replace it with a bad, when i can have it the other way around?

Hey, Volker's got it! Use version 3, but call them add-i, sub-i, 
...

That's the REBOL style.

one of the "bad" should be good", but you understand what i mean.. 
;)

3b is better than 3, but still not necessary.

Part of what makes rebcode so fast is that it doesn't do path lookup 
for its operations. You would make it drastically slower if you changed 
it so it does.

DideC: Add a choice.
4) INTEGER add-i mul-i div-i ... / DECIMAL add-d mul-d div-d ...

there would not be much path-lookup, only on compilation. i dont 
know how rebcode works internally, i guess the words are not stored 
as rebol-words finally?

Using paths is not in the question (answer is no).

Internally, the opcodes are words that are bound to the system/internal/rebcodes 
context by the assembler. Then those bound words are used as an index 
internally to the implementation. No evaluation is involved at runtime.

That is according to Carl's writings so far.