Test suite for the interpreter for Pifxley.
Chris Pressey, Cat's Eye Technologies.

    -> Tests for functionality "Interpret Pifxley Program"

Note: this file is just a copy of `src/tests.markdown` with the
tests for `cond` replaced with tests for `if`.  I should probably
do something better than that someday (and that applies to the whole
test system in the Pixley distribution.)

Constructing and Manipulating Data
----------------------------------

`quote` evaluates to literally what is in the head of the tail of
the cons cell whose head is `quote`.

    | (quote hello)
    = hello

    | (quote (foo bar))
    = (foo bar)

`cons` lets you create a list from some thing and another list.

    | (cons (quote thing) (quote (rest)))
    = (thing rest)

`car` extracts the head of a list.

    | (car (quote (foo bar)))
    = foo

`cdr` extracts the tail of a list.

    | (cdr (quote (foo bar)))
    = (bar)

Predicates and Types
--------------------

Because booleans don't actually have a defined representation in
Pixley, the next few tests are cheating a bit, relying on Scheme's
defined representation for booleans instead.  This would be easy
to fix up, but a bit tedious: just wrap each of these in

    (cond (... (quote true)) (else (quote false)))

`equal?` works on symbols.

    | (equal? (quote a) (quote a))
    = #t

    | (equal? (quote a) (quote b))
    = #f

`equal?` works on lists.

    | (equal? (quote (one (two three)))
    |         (cons (quote one) (quote ((two three)))))
    = #t

A symbol is not a list.

    | (list? (quote a))
    = #f

A list whose final cons cell's tail contains a null, is a list.

    | (list? (cons (quote a) (quote ())))
    = #t

    | (list? (quote (a b c d e f)))
    = #t

A pair is not a list.

Actually, pairs aren't defined at all in Pixley, so I wouldn't
blame an implementation for just freaking out at this one.

    | (list? (cons (quote a) (quote b)))
    = #f

Booleans are not lists.

    | (list? (equal? (quote a) (quote b)))
    = #f

Lambda functions are not lists.

    | (list? (lambda (x y) (y x)))
    = #f

But the empty list is a list.

    | (list? (quote ()))
    = #t

    | (list? (cdr (quote (foo))))
    = #t

The empty list can be expressed as `(quote ())`.

    | (equal? (cdr (quote (foo))) (quote ()))
    = #t

Binding to Names
----------------

`let*` lets you bind identifiers to values.  An identifier can be bound
to a symbol.

    | (let* ((a (quote hello))) a)
    = hello

`let*` can appear in the binding expression in a `let*`.

    | (let* ((a (let* ((b (quote c))) b))) a)
    = c

`let*` can bind a symbol to a function value.

    | (let* ((a (lambda (x y) (cons x y))))
    |       (a (quote foo) (quote ())))
    = (foo)

Bindings established in a binding in a `let*` can be seen in
subsequent bindings in the same `let*`.

    | (let* ((a (quote hello)) (b (cons a (quote ())))) b)
    = (hello)

Shadowing happens.

    | (let* ((a (quote hello))) (let* ((a (quote goodbye))) a))
    = goodbye

`let*` can have an empty list of bindings.

    | (let* () (quote hi))
    = hi

Decision-making
---------------

`if` works.

    | (let* ((true (equal? (quote a) (quote a))))
    |   (if true (quote hi) (quote lo)))
    = hi

    | (let* ((false (equal? (quote a) (quote b))))
    |   (if false (quote hi) (quote lo)))
    = lo

Functions
---------

You can define functions with `lambda`.  They can be anonymous.

    | ((lambda (a) a) (quote whee))
    = whee

Bindings in force when a function is defined will still be in force
when the function is applied, even if they are not lexically in scope.

    | ((let*
    |    ((a (quote (hi)))
    |     (f (lambda (x) (cons x a)))) f) (quote oh))
    = (oh hi)

Functions can take functions.

    | (let*
    |   ((apply (lambda (x) (x (quote a)))))
    |   (apply (lambda (r) (cons r (quote ()))))) 
    = (a)

Functions can return functions.

    | (let*
    |   ((mk (lambda (x) (lambda (y) (cons y x))))
    |    (mk2 (mk (quote (vindaloo)))))
    |   (mk2 (quote chicken)))
    = (chicken vindaloo)