Test Suite for Mascarpone
=========================

This test suite is written in the format of Falderal 0.9.  It is far from
exhaustive, but provides a basic sanity check on the language.

Mascarpone Tests
----------------

    -> Functionality "Interpret Mascarpone Program" is implemented by
    -> shell command
    -> "bin/mascarpone %(test-body-file)"

    -> Functionality "Interpret Mascarpone Program and Show Final State"
    -> is implemented by shell command
    -> "bin/mascarpone -r %(test-body-file)"

    -> Tests for functionality "Interpret Mascarpone Program"

Test nesting quotes.

    | [o[ll]eh].........
    = ]he]ll[o[

Make a new operation, defined as `,.`, and execute it.

    | [,.]v*!
    + Z
    = Z

Redefine `&` as `,.` in the current interpreter, and try it.

    | v[,.]v*'&<^&&&
    + Zil
    = Zil

Like the previous, but restore the old interpreter afterwards.

    | vv[,.]v*'&<^&&&^&&
    + Zam
    = Zam

Define an operation that modifies the caller's interpreter.
The operation `&` causes `m` to be redefined as `,.`.

    | v[v{[,.]v*'m<v}^]v*'&<^mmmmm&mm
    + ZK
    = ZK

"Capture" a value in an operation: given a value, push
an operation that pushes that value when executed.

We want to push the string

    ['v]

onto the stack, where v is the value we were given.  So we:

    push [
    swap
    push '
    swap
    push ]

Then we are ready to make the operation.

    | v['[/''/']v*]v*'?<^'p?!.
    = p

Treat an interpreter as a store.  Define `S` to mean,
pop a symbol, a value, and an interpreter, and push a new
interpreter where the symbol means "push that value."
Then define `F` to mean, pop a symbol and an interpreter,
then extract the operation so named and run it (pushing
the value stored.)

    | v['[/''/']v*]v*'?<^v[/?/<]v*'S<[>!]v*'F<^[]v*1'p'kS'kF.
    = p

Get whatever definition the interpreter sees fit to give
us for a symbol input from the user, and output it.  We
define `?` as above, and then inquire as to the definition
of `?`.

(Note that the reified definitions of symbols are implementation-
specific, and therefore that this test is *non*-normative with
respect to the Mascarpone language itself.)

    | v['[/''/']v*]v*'?<^v,>@$............
    + ?
    = ]*v]'/''/['[

Demonstrate how one can use `*` after `@`.

    | v['[/''/']v*]v*'?<^vv'?>@$v*'?<^'k?!.
    = k

Demonstrate that we cannot make an interpreter which is
its own parent.  Setting the parent of an interpreter
does not modify that interpreter; it produces a copy.

    | vv}^'k.
    = k