## Pail.md @develop-2019-2 — view markup · raw · history · blame

# 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]
```