View Source Document

# 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 [
|      **[*let [
|           [g [x [y z]]]
|        ]]
|   ]]
= 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]
``````