Tests that used to be in Tamsin's README
========================================

    -> Tests for functionality "Intepret Tamsin program"

Hello, world!

    | main = 'Hello, world!'.
    = Hello, world!

Make a story more exciting!

    | main = ("." & '!' | "?" & '?!' | any)/''.
    + Chapter 1
    + ---------
    + It was raining.  She knocked on the door.  She heard
    + footsteps inside.  The door opened.  The butler peered
    + out.  "Hello," she said.  "May I come in?"
    = Chapter 1
    = ---------
    = It was raining!  She knocked on the door!  She heard
    = footsteps inside!  The door opened!  The butler peered
    = out!  "Hello," she said!  "May I come in?!"

Parse an algebraic expression for syntactic correctness.

    | main = (expr0 & eof & 'ok').
    | expr0 = expr1 & {"+" & expr1}.
    | expr1 = term & {"*" & term}.
    | term = "x" | "y" | "z" | "(" & expr0 & ")".
    + x+y*(z+x+y)
    = ok

Parse an algebraic expression to a syntax tree.

    | main = expr0.
    | expr0 = expr1 → E1 & {"+" & expr1 → E2 & E1 ← add(E1,E2)} & E1.
    | expr1 = term → E1 & {"*" & term → E2 & E1 ← mul(E1,E2)} & E1.
    | term = "x" | "y" | "z" | "(" & expr0 → E & ")" & E.
    + x+y*(z+x+y)
    = add(x, mul(y, add(add(z, x), y)))

Translate an algebraic expression to RPN (Reverse Polish Notation).

    | main = expr0 → E & walk(E).
    | expr0 = expr1 → E1 & {"+" & expr1 → E2 & E1 ← add(E1,E2)} & E1.
    | expr1 = term → E1 & {"*" & term → E2 & E1 ← mul(E1,E2)} & E1.
    | term = "x" | "y" | "z" | "(" & expr0 → E & ")" & E.
    | walk(add(L,R)) = walk(L) → LS & walk(R) → RS & return LS+RS+' +'.
    | walk(mul(L,R)) = walk(L) → LS & walk(R) → RS & return LS+RS+' *'.
    | walk(X) = return ' '+X.
    + x+y*(z+x+y)
    =  x y z x + y + * +

Reverse a list.

    | main = reverse(pair(a, pair(b, pair(c, nil))), nil).
    | reverse(pair(H, T), A) = reverse(T, pair(H, A)).
    | reverse(nil, A) = A.
    = pair(c, pair(b, pair(a, nil)))

Parse and evaluate a Boolean expression.

    | main = expr0 → E using scanner & eval(E).
    | expr0 = expr1 → E1 & ("or" & expr1)/E1/or.
    | expr1 = term → E1 & ("and" & term)/E1/and.
    | term = "true" | "false" | "(" & expr0 → E & ")" & E.
    | eval(and(A, B)) = eval(A) → EA & eval(B) → EB & and(EA, EB).
    | eval(or(A, B)) = eval(A) → EA & eval(B) → EB & or(EA, EB).
    | eval(X) = X.
    | and(true, true) = 'true'.
    | and(A, B) = 'false'.
    | or(false, false) = 'false'.
    | or(A, B) = 'true'.
    | scanner = scan using $:utf8.
    | scan = {" "} & ("(" | ")" | token).
    | token = "f" & "a" & "l" & "s" & "e" & 'false'
    |       | "t" & "r" & "u" & "e" & 'true'
    |       | "o" & "r" & 'or'
    |       | "a" & "n" & "d" & 'and'.
    + (falseortrue)andtrue
    = true

Parse a CSV file and write out the 2nd-last field of each record.  Handles
commas and double-quotes inside quotes.

    | main = line → L & L ← lines(nil, L) &
    |        {"\n" & line → M & L ← lines(L, M)} & extract(L) & ''.
    | line = field → F & {"," & field → G & F ← fields(G, F)} & F.
    | field = strings | bare.
    | strings = string → T & {string → S & T ← T + '"' + S} & T.
    | string = "\"" & (!"\"" & any)/'' → T & "\"" & T.
    | bare = (!(","|"\n") & any)/''.
    | extract(lines(Ls, L)) = extract(Ls) & extract_field(L).
    | extract(L) = L.
    | extract_field(fields(L, fields(T, X))) = print T.
    | extract_field(X) = X.
    + Harold,1850,"21 Baxter Street",burgundy
    + Smythe,1833,"31 Little Street, St. James",mauve
    + Jones,1791,"41 ""The Gardens""",crimson
    = 21 Baxter Street
    = 31 Little Street, St. James
    = 41 "The Gardens"

Evaluate a trivial S-expression-based language.

    | main = sexp → S using scanner & reverse(S, nil) → SR & eval(SR).
    | scanner = ({" "} & ("(" | ")" | $:alnum/'')) using $:utf8.
    | sexp = $:alnum | list.
    | list = "(" & sexp/nil/pair → L & ")" & L.
    | head(pair(A, B)) = A.
    | tail(pair(A, B)) = B.
    | cons(A, B) = return pair(A, B).
    | eval(pair(head, pair(X, nil))) = eval(X) → R & head(R).
    | eval(pair(tail, pair(X, nil))) = eval(X) → R & tail(R).
    | eval(pair(cons, pair(A, pair(B, nil)))) =
    |    eval(A) → AE & eval(B) → BE & return pair(AE, BE).
    | eval(X) = X.
    | reverse(pair(H, T), A) = reverse(H, nil) → HR & reverse(T, pair(HR, A)).
    | reverse(nil, A) = A.
    | reverse(X, A) = X.
    + (head (tail (cons (cons a nil) (cons b nil))))
    = b

Escape characters in a string, for use in a C program source.

    | main = escaped('"♥\n«"').
    | escaped(S) = escaped_r @ S.
    | escaped_r = A ← '' &
    |     {
    |         "\\" & A ← A + '\\\\'
    |       | "\"" & A ← A + '\\"'
    |       | "\n" & A ← A + '\\n'
    |       | $:alnum → B & A ← A + B
    |       | any → B & (many_format_octal @ B) → B & A ← A + B
    |     } & A.
    | 
    | many_format_octal =
    |     S ← '' &
    |     {any → B & $:format_octal(B) → B & S ← S + '\\' + B} using $:byte &
    |     S.
    = \"\342\231\245\n\302\253\"