infix prec (MMCK Infix)

3.2 Operators precedence

To determine sensible precedences for operators, we make the following observations:

Logical operators (and, or, not, …) are meant to be applied to predicate operand expressions and they return a boolean value.
Numeric comparison operators (=, <, >, …) are meant to be applied to numeric operand expressions and they return a boolean value.
Arithmetic operators (+, -, *, /, …) are meant to be applied to numeric operand expressions and they return a numeric value.
The C language has established a tradition of writing expressions containing bitwise operators 1 & 2 + ~ 3 meaning (1 & 2) + (~ 3), in which bitwise operators take precedence over every other operator.
It makes sense to write expressions like 1 < i and i < 4 meaning (1 < i) and (i < 4), because it makes no sense to interpret it as 1 < (i and i) < 4.
It makes sense to write expressions like 1 + 2 < 3 + 4 meaning (1 + 2) < (3 + 4), because it makes no sense to interpret it as 1 + (2 < 3) + 4.

So MMCK Infix defines operators precedence as follows, from high precedence to low precedence:

Procedure application: the left parenthesis preceeded by an identifier starts a procedure application.

Binary infix bitwise shift operators:

bitwise-arithmetic-shift-left
bitwise-arithmetic-shift-right
fxshl
fxshr

Unary prefix bitwise operators:
```
bitwise-not fxnot
```

Binary infix bitwise operators:

bitwise-and bitwise-ior bitwise-xor
fxand fxior fxxor

Unary prefix arithmetic operators:
```
+ - ++ -- fx+ fx- fp+ fp-
```
Unary postfix arithmetic operators:
```
++ -- !
```
Binary infix arithmetic exponentiation operators:
```
expt fpexpt
```
Binary infix arithmetic modulo operators:
```
quotient modulo remainder
```
Binary infix multiplication and division arithmetic operators:
```
* / fp* fp/ fx* fx/
```
Binary infix addition and subtraction arithmetic operators:
```
+ - fp+ fp- fx+ fx-
```

Comparison operators:

< > <= >= = !=
fx< fx> fx<= fx>= fx=
fp< fp> fp<= fp>= fp=
eq? eqv? equal?

Unary prefix logical operators:
```
not
```
Binary infix logical operators:
```
and or xor
```
Ternary conditional operator … ? … : ….
Procedure application arguments separator, which is the comma.

Here some expansion examples:

(infix ! 2 + 3)         → (not (2 + 3))
(infix (! 2) + 3)       error→ expected numeric argument

(infix fxnot 3)         ⇒ -4
(infix fxnot 3 + 10)    ⇒ 6

(infix ! cos(3))        → (not (cos 3))

Precedence exceptions

The Pratt parser allows the same operator to have different precedence when it is present in prefix position or in postfix position. So under (mmck infix) the following expansion takes place:

(infix ! 1 + 2)         → (not (+ 1 2))

This document describes version 0.1.0-devel.0 of MMCK Infix.