Test suite for our R5RS Pixley interpreter. Chris Pressey, Cat's Eye Technologies.

-> Tests for functionality "Interpret Pixley Program"

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 (quote quote))
= (quote quote)

Atomic symbols may contain letters, *s, ?s, and -s.

| (quote abcdef-ghijklm*nopqrst?uvwxyz)
= abcdef-ghijklm*nopqrst?uvwxyz

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

equal? works on symbols.

| (cond (
| (equal? (quote a) (quote a))
|   (quote true)) (else (quote false)))
= true

| (cond (
| (equal? (quote a) (quote b))
|   (quote true)) (else (quote false)))
= false

equal? works on lists.

| (cond (
| (equal? (quote (one (two three)))
|         (cons (quote one) (quote ((two three)))))
|   (quote true)) (else (quote false)))
= true

A symbol is not a list.

| (cond (
| (list? (quote a))
|   (quote true)) (else (quote false)))
= false

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

| (cond (
| (list? (cons (quote a) (quote ())))
|   (quote true)) (else (quote false)))
= true

| (cond (
| (list? (quote (a b c d e f)))
|   (quote true)) (else (quote false)))
= true

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.

| (cond (
| (list? (cons (quote a) (quote b)))
|   (quote true)) (else (quote false)))
= false

Booleans are not lists.

| (cond (
| (list? (equal? (quote a) (quote b)))
|   (quote true)) (else (quote false)))
= false

Lambda functions are not lists.

| (cond (
| (list? (lambda (x y) (y x)))
|   (quote true)) (else (quote false)))
= false

But the empty list is a list.

| (cond (
| (list? (quote ()))
|   (quote true)) (else (quote false)))
= true

| (cond (
| (list? (cdr (quote (foo))))
|   (quote true)) (else (quote false)))
= true

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

| (cond (
| (equal? (cdr (quote (foo))) (quote ()))
|   (quote true)) (else (quote false)))
= true

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

cond works.

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

| (let* ((true (equal? (quote a) (quote a)))
|        (false (equal? (quote a) (quote b))))
|   (cond (false (quote hi)) (true (quote med)) (else (quote lo))))
= med

| (let* ((true (equal? (quote a) (quote a)))
|        (false (equal? (quote a) (quote b))))
|   (cond (false (quote hi)) (false (quote med)) (else (quote lo))))
= lo

cond can have zero tests before the else.

| (cond (else (quote woo)))
= woo

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)

You can call a function with a bound name as its argument.

| (let* ((interpret
|         (lambda (program)
|           (let* ((interpreter (quote z)))
|             (cons interpreter program))))
|        (sexp (quote (cdr (quote (one two three))))))
|   (interpret sexp))
= (z cdr (quote (one two three)))

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)