The evaluation semantics

== op! Yes, the infix operators (+ - * /) behave a bit differently than other "normal" rebol functions and actions. The explanation I remember is that an expression such as: arg1 + arg2 becomes (internally) + arg1 arg2 so that it is then like any other rebol function. In your example, the + would have jumped just in front of the string, and then took two arguments boat and 2, and tried to add them together. You can rewrite it like this: + length? "boat" 2 But what we usually end up writing is: (length? "boat") + 2 or 2 + length? "boat" being conscious that in tight loops parens slow things down a tiny bit. Anton.

Little bit off-topic: I was wondering, what is faster? arg1 + arg2 or add arg1 arg2 ? May seem strange, because first option must be internally translated, but it's faster then 'add.

0:00:02.719 == 0:00:02.719

0:00:03.86 == 0:00:03.86 Bye, Rebolek

BB> 0:00:02.719 BB> == 0:00:02.719

BB> 0:00:03.86 BB> == 0:00:03.86 The reason is that + is somewhat treated like a keyword, while ADD is not. Regards, Gabriele. -- Gabriele Santilli <[gabriele--rebol--com]> --- http://www.rebol.com/ Colella Chiara software division --- http://www.colellachiara.com/

== op!

== action! I think the op!s are more fundamental. They probably get defined first or are earlier in the symbol lookup list. I'm only speculating but it could be something like that. Anton.

** Script Error: Invalid operator: + ** Near: 1 + 2 Regards, Gabriele. -- Gabriele Santilli <[gabriele--rebol--com]> --- http://www.rebol.com/ Colella Chiara software division --- http://www.colellachiara.com/

That's because length? "boat" returns it's value to the physical left of itself, e.g.: 4 <- length? "boat" and not length? "boat" -> 4 + requires a value on each side where the one on the left, returns a value to its right, e.g.: <value> -> + <- <value> but your statement produces: <- <value> + <- <value> The (very) new Wikibook has a bit about this, actually: http://en.wikibooks.org/wiki/ Programming:REBOL#Simple_Programming_in_the_Console The part about parentheses is not entirely accurate yet, but it should fit with what you need. -- Regards, Henrik Mikael Kristensen

Actually, the reasoning is different. The fact is, that the + operator has precedence over the length? function. Therefore the first opearation the interpreter tries to evaluate is: "boat" + 4 , which results in an error. -L

To me the number of exceptions is quite low: Rebol looks at the next two values at the same time. If you have a value followed by an operator, it is evaluated first. If it is followed by another value+operator, these are evaluated left to right. Else it uses the next value, as we are used too. abs -4 + -5 rebol sees "abs -4". No op, so takes "abs". Then "-4 +". Operator. Now it introduces a paren (so to speak). That gives "abs ( -4 +" First thing is closing that paren with the -5: "abs ( -4 + (-5) )" and that gives 9. -4 + abs -5 rebol sees "-4 +". introducing paren: (-4 + . The right side has no more operators, so rebol sees only "abs". Normal evaluation. "Abs" needs one arg. There is "-5 end-of-block". No operator. So "abs -5". That is "joined": ( -4 + (abs - 5) ) As a result, an operator can "steal" an argument from the left function. Thus with abs -4 + -5 the "+" can steal the -4. with -4 + abs -5 there is nothing which can be stolen from. That is why rebol-conditions sometimes looks "reversed", if "volker" = ask "your name?" [..] instead of if ask "your name?" = "volker" [..] The "=" cant steal in the second case. Thus we need to write if (ask "your name?") = "volker" [..] and since we are lazy we save that paren. :)

-- -Volker Any problem in computer science can be solved with another layer of indirection. But that usually will create another problem. David Wheeler

As I said, there *are* exceptions: abc: func [:x] [abs x] abc -4 + -5 ; == -1 -L

Agreed, and abc: func ['x] [abs x] But these are intended. Maybe we use different meanings for "exceptions"? To me they are "watch out", hard to explain, surprising things. While rebols follows IMHO some simple, but not that obvious rules. Which i tried to explain. 'x and :x in argument-lists say "dont look further". That operator-evaluation is not applied then seems reasonable to me. But yes, these are exceptions. (actually i never used :x, its like 'x with a little difference (hmm, = exception ;) i guess?)

-- -Volker Any problem in computer science can be solved with another layer of indirection. But that usually will create another problem. David Wheeler

.... yes, they are surprising, I could have used surprises instead of exceptions, if you prefer. Another surprise is this: probe + 1 2 ; == 3 (at least I think, that it looks like a surprise, or exception) Anyway, the fact is, that such exceptions/surprises are common in natural languages too, where you can hardly find a rule without exceptions. -L

The trouble is, that this description is unreadable for beginners and it cannot be easily amended to reflect all exceptional cases.

-- Behrang Saeedzadeh http://www.jroller.com/page/behrangsa

Do you have a link to this?

Here's a more permanent explanation http://en.wikibooks.org/wiki/REBOL_Programming/Programming_in_REBOL#Precedence Well, permanent until someone else changes it :) -- Graham Chiu

Go to http://www.rebol.com/docs/core23/rebolcore-3.html and search for precedence . This is what you'll find: In REBOL there are no special operator precedence rules for evaluating blocks. The values and words of a block are always evaluated from first to last, as shown in the following example [...]

Thanks for the WIKI link. I'll definitely have a look at it. Cheers, Behi -- Behrang Saeedzadeh http://www.jroller.com/page/behrangsa