Test Suite for Pail
===================

This test suite is written in the format of Falderal 0.7.  It is far from
exhaustive, but provides a basic sanity check that the language I've designed
here comes close to what I had in mind.

Pail Tests
----------

    -> Tests for functionality "Evaluate Pail Expression"

A symbol reduces to that symbol.

    | fst
    = fst

    | plains-of-leng?
    = plains-of-leng?

A symbol must begin with a letter and contain only letters, digits,
hyphens, and question marks.

    | ^hey
    = %(line 1, column 1):
    = unexpected "^"
    = expecting white space, "*", "#", "[" or letter

A pair reduces to that pair.

    | [a b]
    = [a b]

    | [fst [a b]]
    = [fst [a b]]

    | [*fst [a b]]
    = [*fst [a b]]

Square brackets must be properly matched.

    | [a b
    = %(line 1, column 5):
    = unexpected end of input
    = expecting letter or digit, "-", "?", "_", white space or "]"

Evaluation of a symbol reduces to that to which it is bound.

    | *fst
    = <fst>

Evaluation of a pair recursively reduces its contents.

    | *[*fst [a b]]
    = [<fst> [a b]]

    | *[*fst *snd]
    = [<fst> <snd>]

    | *[*fst *[*snd *fst]]
    = [<fst> [<snd> <fst>]]

Evaluation of a pair w/a fun on the lhs applies the fun.

    | **[*fst [a b]]
    = a

    | **[*snd [a b]]
    = b

Reducing an evaluation of a pair can accomplish a cons.

    | *[**[*fst [a b]] **[*snd [c d]]]
    = [a d]

Reducing on the lhs of a pair can obtain a fun to apply.

    | **[**[*fst [*snd *fst]] [a b]]
    = b

Applying uneval reduces to an evaluation.

    | **[*uneval hello]
    = *hello

The form `#x` is syntactic sugar for `**[*uneval x]`.

    | #hello
    = *hello

Syntactic sugar is expanded at parse time.

    | [#fst [a b]]
    = [**[*uneval fst] [a b]]

It is possible to uneval a fun.

    | #*fst
    = *<fst>

Reduction of an uneval'ed symbol can be used to obtain an eval'ed symbol.

    | *[#fst [a b]]
    = [*fst [a b]]

Reduction of uneval'ed symbol can be used to obtain a fun.

    | **[#fst [a b]]
    = [<fst> [a b]]

Reduction of uneval'ed symbol can be used to apply the obtained fun.

    | ***[#fst [a b]]
    = a

Positive test of `if-equal?` on symbols.

    | **[*if-equal? [[a a] [one two]]]
    = one

Negative test of `if-equal?` on symbols.

    | **[*if-equal? [[a b] [one two]]]
    = two

Negative test of `if-equal?` on evals.

    | ***[*if-equal? [[*a *b] [fst snd]]]
    = <snd>

Let can bind a symbol to a symbol.

    | **[*let [[a b] *a]]
    = b

Let can bind a symbol to a pair.

    | **[*let [[g [x y]] **[*snd *g]]]
    = y

Let can bind a symbol to an expression containing an uneval,
which can at a later point be eval'ed and reduced.

    | **[*let [
    |      [sndg *[**[*uneval snd] **[*uneval g]]]
    |      **[*let [
    |           [g [x y]]
    |           ***sndg
    |        ]]
    |   ]]
    = y

    | **[*let [
    |      [cadrg *[#fst ##*[#snd #g]]]
    |      **[*let [
    |           [g [x [y z]]]
    |           ***cadrg
    |        ]]
    |   ]]
    = y

Let can bind uneval'ed expression; prior bindings are honoured.

    | **[*let [
    |      [g moo]
    |      **[*let [
    |           [consnull *[#g null]]
    |           ***consnull
    |        ]]
    |   ]]
    = [moo null]

Let can bind uneval'ed expression; prior bindings are shadowed.

    | **[*let [
    |      [g moo]
    |      **[*let [
    |           [consnull *[#g null]]
    |           **[*let [
    |                [g k]
    |                 ***consnull
    |             ]]
    |        ]]
    |   ]]
    = [k null]