A newline ends a statement if it can, otherwise it acts like any white space.

Here is the way these numbers work. The parser maintains a number which called the current parsing level, or simply, the level. The parser builds up an expression until it encounters an input token whose parsing precedence is less than or equal to the current level. The tokens preceding the offending token are bundled into an expression appropriately and incorporated into the containing expression.

i1 : 2+ 3+ 4 o1 = 9 |

Parsing is determined by a triple of numbers attached to each token. The following table (produced by the command seeParsing), displays each of these numbers.

parsing binary unary precedence binding binding operators strength strength 2 2 -*end of file*- 4 4 -*end of cell*- 6 ) ] |> } 8 7 ; 10 10 10 , 12 12 do else list then 14 13 -> := <- = => >> 16 16 from in of to when 18 18 18 << 20 19 20 |- 22 21 ===> 22 21 22 <=== 24 23 <==> 26 25 ==> 26 25 26 <== 28 27 or 30 29 xor 32 31 and 34 34 not 36 35 != =!= == === 36 35 36 < <= > >= ? 38 38 || 40 39 : 42 42 | 44 44 ^^ 46 46 & 48 48 .. ..< 50 50 ++ 50 50 50 + - 52 52 ** 54 6 <| [ 56 55 \ \\ 56 56 % / // 56 56 56 * 58 57 @ 60 -*...symbols...*- 60 6 ( { 60 12 break catch continue elapsedTime elapsedTiming if return shield step throw time timing try while 60 16 for new 60 72 global local symbol threadVariable 60 59 SPACE 62 (*) 64 64 @@ 66 ^* _* ~ 68 68 #? . .? ^ ^** _ 68 68 59 # 70 ! |

When an operator or token is encountered, its binding strength serves as the level for parsing the subsequent expression, unless the current level is higher, in which case it is used.

Consider a binary operator such as `*`. The relationship between its binary binding strength and its parsing precedence turns out to determine whether `a*b*c` is parsed as `(a*b)*c` or as `a*(b*c)`. When the parser encounters the second `*`, the current parsing level is equal to the binding strength of the first `*`. If the binding strength is less than the precedence, then the second `*` becomes part of the right hand operand of the first `*`, and the expression is parsed as `a*(b*c)`. Otherwise, the expression is parsed as `(a*b)*c`.

For unary operators, the unary binding strength is used instead of the binary binding strength to reset the current level. The reason for having both numbers is that some operators can be either unary or binary, depending on the context. A good example is # which binds as tightly as . when used as an infix operator, and binds as loosely as adjacency or function application when used as a prefix operator.

To handle expressions like `b c d`, where there are no tokens present which can serve as a binary multiplication operator, after parsing `b`, the level will be set to 1 less than the precedence of an identifier, so that `b c d` will be parsed as `b (c d)`.

The comma and semicolon get special treatment: the empty expression can occur to the right of the comma or semicolon or to the left of the comma.

One of the most unusual aspects of the parsing precedence table above is that `[` is assigned a precedence several steps lower than the precedence of symbols and adjacency, and also lower than the precedence of `/`. This was done so expressions like `R/I[x]` would be parsed according to mathematical custom, but it implies that expressions like `f g [x]` will be parsed in a surprising way, with `f g` being evaluated first, even if `f` and `g` are both functions. Suitably placed parentheses can help, as illustrated in the next example.

i2 : f = x -> (print x; print) o2 = f o2 : FunctionClosure |

i3 : f f [1,2,3] f [1, 2, 3] |

i4 : f f ([1,2,3]) [1, 2, 3] print o4 = print o4 : FunctionClosure |

i5 : f (f [1,2,3]) [1, 2, 3] print o5 = print o5 : FunctionClosure |