Falderal

* For ease of installation, the project is presented as a Cabal package.
* A driver executable, `falderal`, is built as part of installing the
Cabal package. It provides a command-line interface to formatting
Falderal files and, in a limited fashion, running the tests in them.
* A shell script formatter has been written, enabling testing of shell
commands. One caveat is that reporting for these tests is nowhere near
as nice as for Haskell functions, but that will change in the next version.
* The Functionality-definition pragma has been implemented, making it
possible to write tests in a more abstract, implementation-independent
fashion.
* Falderal files written to work with Falderal 0.3 should still work with
Falderal 0.4, but you are encouraged to use the Functionality-definition
pragma introduced in 0.4 to make your tests more implementation-independent.

* The definition of a Falderal Literate Test Format, distinct from the
reference implementation of tools for it in Haskell (`Test.Falderal`).
This represented a fairly substantial departure from how previous versions
of Falderal worked.
* The ability to format a Falderal file to different formats, including
Markdown and Haskell.
* Running tests is now a matter of formatting a Falderal file as a Haskell
module and running the function `testModule` in that module.

* Added a test harness for Falderal itself, in the form of a simple shell
script which diffs the output of `Test.Falderal.Demo` against a text file
containing the expected content.
* Improved formatting of failure reports. Multi-line input text or expected
output is always presented starting on its own line.
* Tests may be organized into groups; the entire group is preceded by some
literal text, but there is no literal text between the tests in the group.
When one of these tests fails, the literal text for the group is reported,
along with the number of the test within the group.
* Fixed a bug where exception text which extended over multiple lines
could not be expected correctly.

* Provision of a framework for writing and running literate tests which may
be embedded in literate Haskell source code.
* Testing Haskell functions of type `String -> String`. A test specifies input
to the function, and may expect a particular output, or that a particular
exception is thrown.
* Through simple adapters, testing functions of other types such as
`(Show a) => String -> a`.

Prehistory:

Falderal started life as a Haskell-specific hack that could be embedded
in a Bird-style Literate Haskell source file. I took a framework for
literate tests I had already written in a project called _Rho_, and used it
as the basis of this code.

I wrote it because I was designing yet another esoteric programming
language, and while working on it I realized I was rebuilding yet another
ad-hoc unit test suite, like I had done a half-dozen times before. I didn't
want to keep doing this for every language I designed, and I realized that
literate test suites could serve as documentation as well; the result was
Falderal.