:= ... := '=' ';'
:= '=' ';'
 '=' ';'
:= ... := '(' ',' ... ',' ')'
:=

 '(' ',' ... ',' ')'
 '[' ',' ... ',' ']'


 'if' 'then' 'else'

 'fn' ... '>'
 'let' ... 'in'
 'letrec' ... 'in'
 'case' 'of' ';' := '[]' '>' := ':' '>' := 'neg'  'not'  := '#' +
A program consists of a sequence of (recursive) declarataions. One of
the declarations must define a variable 'main'. A program is
eqiuvalent of a letrecexpression:
'letrec' ... 'in' 'main';
Deaclarations are equations terminated with semicolon ';'.
Righthandside of declarations is an expression. Lefthandside
is either a function pattern or tuple pattern. (Tuple patterns are
allowed only in letexpressions, and not in letrecexpressions).
A declaration in a form "f x1 x2 ... xn = exp" is equivalent with
"f = fn x1 x2 ... xn > exp".
All expression constructs extend as far to the right as possible.
Expressions "( e1, ... , en )" are tuple expressions for n > 1
or n = 0. If n = 1, then the expression "( e1 )" is not a tuple, but
equivalent to "e1" (in this case parenthesis are just delimiters).
Expressions "[ e1, ... , en ]" are list expressions. The expression
"[]" (ie. n = 0) denotes an empty list constructor. For n > 0, list
expressions are just shorthand for "e1 : e2 : ... : en : []".
Binary operators are grouped in the grammar by precedences
(multiplicative operators '*', '/", '%' bind tightest, logical or
'' binds weakest). All binary operators are leftassociative,
except list constructor ':', which is rightassociative.
Function application and unary operators bind tighter than any
binary operator (ie. "f 3 + 4" is equivalent to "(f 3) + 4").
Application is leftassotiative (ie. "f 3 4" is equivalent to
"(f 3) 4".
Semantics is callbyvalue.
At the beginning of a file there can be include statements in form:
#include failname.puf
This includes the contents of the file 'failname.puf' verbatim (like
include statements in C).
Comments in the language are C/C++ style; ie. normal comments are
in between /* ... */ and comments till the endofline //