World: r3wp

>> 5 - 2
== 3
>> 5 negate 2
== -2

only in rare case

you need absotutely negate instead of -

OK, this case looks rare to you, how about this case:
    add 5 negate x ...
    add 5 - x

rare case , at least for me,  in my experience, and you can always 
use

add 5 ( - x )

which is also more fast

yes, I can, it just needs parentheses, i.e. may be considered less 
readable (a matter of taste, I think)

e.g. Carl is preferring to use NEGATE instead of parenthesized - 
AFAICT

Taking the example with add, 5, negate and x, we can write:
add 5 negate x
add 5 (- x)
5 + negate x
5 + (- x)
+ 5 negate x
+ 5 (- x)


and using Ladislav's +-: :negate, you can change negate to +- in 
the above. In REBOL there're really many ways to write even the simplest 
thing.

also:
5 + - 2

And if x is negative:
5 + - -2
:-)

I think that was a wrong choice to permit the use of op! like action!

This last one is just not as readable as: 5 + negate x
(I think)

This is a *very* tricky thing in REBOL!

It was a difficult decision to allow it.

>> - 10
== -10
>> 5 + - 10
== -5

It is? :-) It's good to have choices, when it comes to expressing 
yourself.

In fact, supporting unary minus slows down REBOL, because it is a 
single "special case" condition within the evaluation processs.

oh, hmm a hit on performance may not be so good.

what do you personally think about using +- as a shortcut for NEGATE?

I am not fond of the idea of using plusminus for negate.  I have 
seen tilde used to denote negation and would perfer something visably 
distinct

Carl, didn't you write some guidelines for the order of arguments 
to functions at some time? That destination arguments should be first, 
source later.

tilde is not very accessible using the Czech keyboard

it is the context which select - as
1) unary minus (- 2)
2) subtract op!  (2 - 3)
3) subtract action! (- 2 3)
- is a monster! :-)

:-)

WRT +-  It seemed to me that there was another good reason to give 
that other meaning.

It is possible to imagine a "range" or "interval" datatype that may 
need +- word.

Regarding order of arguments:

The fundamental rule is an abstraction - it is this: the primary 
"focus" or "object" of the function or action is first.

Makes sense.

So it is: verb main-object modifiers (or other objs)

(Rather than direction of evaluation flow or direction of human reading 
flow.)

Shells often use: verb source destination

Carl, I ask, because I'm writing REBOL-versions of some of the old 
Amiga graphics.library functions. BltBitMap e.g., in the Amiga version, 
the arguments are: source bitmap, source position, destination bitmap, 
destination position, mask, etc...
Should I turn source and destination around in a REBOL version?

In that case, when source and destination are of equal weight, then 
you can apply other rules.

Or rather: what would you do?

ok

It depends on if you want to keep it true to the Amiga order, or 
if you are creating something new.

I plan to let the functions be available to other developers, so 
I was wondering, what people would feel as the right 'REBOL' way.

My idea is, that it's new, but Amiga developers should recognize 
it.

In the example you show above... it seems good.  The source bitmap 
could be considered the primary object, although the dest is also 
very important.

Romano, yes, it is a monster!

Neg for negate may be simplest. We already have abs for absolute.

And, it seems that there are people pushing for sin (sine), cos (cosine), 
tan, etc.

I should remember that the doc of the original functions are in source-destination 
order, so for me is a good idea to make the same in Rebol,  there 
a direct map of OS function and OS doc on rebol functions

Yeah, I should probably keep the order of the arguments, as they 
are in the Amiga version, so it'll be recognizable. Thanks! :-)

The word browser is nice, but I spend most of my time in the console. 
 How about a man command that looks up the manual pages on the net, 
and dumps them to the console?

And since the console responds to escape sequences, we could even 
have some formatting ?

I thought tags were a special form of strings ...

However, this appears not to be the case ...

>> probe rejoin [ "<html>" "testing" "</html>" ]
<html>testing</html>
== "<html>testing</html>"
>> probe rejoin [ <html> "testing" </html> ]
<htmltesting</html>>
== <htmltesting</html>>

>> html: ""
== ""
>> repend html [ <html> "testing" </html> ]
== "<html>testing</html>"