`alv` programs consist of a series of expressions separated by chunks of
whitespace. Each expression may be either a literal constant or a cell.

# literal constants
There are three types of simple literals with different syntax:

## numbers
Numbers consist of the digits `0`-`9` and can optionally begin with a
negative sign and contain a decimal dot. The digits before or after the
decimal point may be left off, but a number needs to consist of at least one
digit.

The following are all valid numbers:

    0
    12
    -7
    0.1
    10.
    .1
    123.

The regular expression `-?(\d+\.\d*|\d*\.\d+|\d+)` matches all numbers. 

## strings
Strings are enclosed by either single (`'`) or double quotes (`"`). Backslashes
and either type of quote can be escaped by prefixing them with a single
backslash, i.e. the literal notation `"\\\""` evaluates to the string `\"`.

The following are all valid strings:

    "hello world"
    'hello world'
    "it's a beautiful day"
    'it\'s a beautiful day'
    "this is a backslash: \\"
    "this is a double quote: \""
    ""
    ''

## symbols
Symbols must start with a letter (`a`-`z` or `A`-`Z`) or one of the following
special characters:

    - + * /
    _ . , =
    ! ? % $
    > < ~

The remaining characters can be letters, special characters from this set, or
digits (`0`-`9`).

The following are all valid symbols:

    helloWORLD
    -
    /
    *dynamic*
    *+*
    var01
    _test
    foo$

The regular expression `[a-zA-Z\-_+*^%\/.,=~!?$><][a-zA-Z0-9\-_+*^%\/.,=~!?$><]*`
matches all symbols.

# cells
Cells consist of one or more subexpressions separated by chunks of whitespace
and enclosed in parentheses (`(` and `)`). A cell optionally contains a tag
immediately after the opening parenthesis. Whitespace between the opening
parenthesis and the first subexpression or the closing parenthesis and the last
subexpression is optional.

The first subexpression is considered the head of the cell and determines the
behaviour of the cell.

## tags
Tags consist of one or more digits (`0`-`9`) enclosed in square brackets (`[`
and `]`). `[1]` and `[255]` are examples of valid tags.

# template strings
Template Strings are a different syntax for cells that allows embedding alv
expressions inside of a string literal. They can be used to perform string
substitution, especially within code of other languages.

Template strings start with the character `$` followed by an optional tag and
a symbol that functions as the head of the cell and finally a `"`-delimited
string literal. Within the string literal, a `$` character begins an
interpolation expression unless escaped by a single preceding blackslash.

The following are example template strings:

    $empty""
    $hello"world"
    $fmt"three is $3 and four is $"four""
    $[99]fmt"five is $(+ 3 2)"
    $fmt"there is \$no substitution here"

Template strings are syntactic sugar that transforms into an array of string
pieces and the values to substitute, the following cell expressions are
semantically identical to the previous examples respectively:

    (empty [""])
    (hello ["world"])
    (fmt ["three is " " and four is " ""] 3 "four")
    ([99]fmt ["five is" ""] (+ 3 2))
    (fmt ["there is $no substitution here"])

# arrays and structs
Array and struct literals too are syntatic shortcuts for the [mkarray][] and
[mkstruct][] builtins respectively.

Arrays are a list of expressions separated by whitespace enclosed in square
brackets (`[` and `]`). Similarly structs are a list of key-value pairs
separated by whitespace and enclosed in curly brackets (`{` and `}`).

Arrays and structs must contain at least one element or key-value pair
respectively.

# whitespace
The space, tab, newline, and line-feed special characters constitute whitespace
and may be repeated any number of times to form a chunk. A chunk of whitespace
may also contain any number of comments, but may neither begin nor end with a
comment.

## comments
A comment cell begins with `#(` and ends with a matching parenthesis `)`.
Comment cells may contain other comments or cells.

Line comments begin with `##` and end at the end of the line. Line comments
have precedence over comment cells, i.e. comment cells within line comments do
not continue past the end of the line.
