# Project F implementation details

1. Program text can contain comments that start with a semicolon (`;`) and end with a newline.
1. The syntax of `func`, `lambda`, `prog`, `while` is as follows:

   ( func Atom List { Element } )
   ( lambda List { Element } )
   ( prog List { Element } )
   ( while Element { Element } )

Elements are evaluated sequentially and the last evaluated value becomes the return value of the corresponding special form (except for `while`).

1. The type "integer" is a 64-bit signed integer.
1. The type "real" is a 64-bit floating-point number.
1. `setq` returns the value just assigned.
1. `prog` returns the last evaluated value.
1. `func` and `lambda` return a function object of the newly created function.
1. A new predicate `isfunc` checks if the passed value is a function object.
1. In a function call, the first element in the list must either be a symbol that names a special operator or evaluate to a function object.
1. `null` refers to the same value as the empty list (`()`).
1. `plus`, `minus`, `times`, `divide` extends their arguments to "real" if any argument is of type "real".
1. `divide` terminates the program if the second argument is the integer 0.
1. If the result of an integer arithmetic operation does not fit into the type "integer", the operation has wrapping behavior.
1. `head` and `tail` return `null` for an empty list.
1. `equal`, `nonequal`, less`, `lesseq`, `greater`, `greatereq` terminate program execution when arguments have different types.
1. `break` breaks the closest `while` or `prog`.
1. `break` inside a `prog` is allowed to accept a value that will be returned from `prog`. The syntax of `break` now is

    ( break [ Element ] )

1. `return` returns from the closest `func` or `lambda` only.
<!--1. `equal` returns `false` when arguments have different types.
1. `nonequal` returns `true` when arguments have different types. -->