Philosophy of Tamsin
====================
I suppose that's a rather heavy-handed word to use, "philosophy". But
this is the document giving the _whys_ of Tamsin rather than the technical
points.
Why did you write Tamin?
------------------------
Basically, every time I see someone use a compiler-compiler like `yacc`
or a parser combinator library, part of me thinks, "Well why didn't
you just write a recursive-descent parser? Recursive-descent parsers
are easy to write and they make for extremely pretty code!"
And what does a recursive-descent parser do? It consumes input. But
don't *all* algorithms consume input? So why not have a language which
makes it easy to write recursive-descent parsers, and force all programs
to be written as recursive-descent parsers? Then *all* code will be pretty!
(Yeah, sure, OK.)
Why is it/is it not a...
------------------------
### Meta-Language ###
(Also known, in their more practical incarnations, as "compiler-compilers"
or "parser generators".)
Tamsin is one, because:
* The basic operations all map directly to combinators in BNF (or rather,
Wirth's EBNF):
* `&` is sequencing
* `|` is alternation
* `[]` is sugar for alternation with the empty string
* `{}` is asteration
* `"foo"` is a terminal
* `foo` is a non-terminal
* Using only these operations produces a sensible program — one which
parses its input by the grammar so given.
Tamsin isn't one, because:
* There is no requirement that any input be processed at all.
### Programming Language ###
Tamsin is one, because:
* Productions can have local variables.
* Productions can call other productions (or themselves, recursively) with
arguments, and they return a value:
reverse(pair(H, T), A) = reverse(T, pair(H, A)).
reverse(nil, A) = A.
* It's Turing-complete.
* It can be, and in fact has been, bootstrapped.
Tamsin isn't one, because:
* The syntax is really geared to consuming input rather than general
programming.
### Rubbish Lister ###
What does this even mean? Well, there is that
[one famous rubbish lister](http://perl.org/) that we can use as an example
for now, until I come up with a better definition here.
Tamsin is one, because:
* There's more than one way to say it.
* The same symbol means different things in different contexts
(for example, `foo` might be either the name of a production, or an
atomic term.)
* Implicit this, implicit that.
* Optomized (a bit) for problem-solving throwaway one-liners rather than
large, engineered systems.
* Anyone up for a game of golf?
Tamsin isn't one, because:
* It's possible to express its syntax in a form that humans can understand.
* In fact, it's possible to express its syntax in Tamsin.
In fact, it's possible to bootstrap Tamsin — a Tamsin-to-C compiler has
been written in Tamsin. This is very un-rubbish-lister-ish.
Batteries Included
------------------
Are batteries included? Or rather, _what_ batteries are included? By strange
coincidence, the batteries that are included are almost exactly the ones
you'd expect to be useful in bootstrapping a Tamsin-to-C compiler:
* `list` module — `reverse`, `append`, `member`, etc.
* `tamsin_scanner` module
* `tamsin_parser` module
* `tamsin_analyzer` module