Start writing a new type checker based on the ATAPL chapter on efficient type-inference.
Start generating constraints for let-expressions. Account for mutual recursion,
but will throw a runtime error if a user has given type annotations.
Start switching over to an AST that uses patterns in lambdas and
pulls the arguments out of Definitions (placing them in lambdas).
Convert more files to the new Expression format that relies more on
patterns. Seems to clean things up so far.

Also, begin adding a module that resorts definitions to make sure
that each definition comes after the ones it depends on. This will
also make it possible to disallow recursive values statically.
Switch more files over to new Expressions
Continue getting the new type-checker in order.
Move the Environment.hs and Fragment.hs files down a directory.
Get Optimize.hs updated for the newer AST.
Start using the PrettyPrint library to show expressions, literals, and patterns.
Create a source syntax for types that will get converted into the internal type representation during type checking.
Create a Parse.Declaration file for all declarations. Get rid of special
purpose Parse.Foreign library.
Update program parser to use Parse.Declarations
Add pretty printing for type constraints.

Convert source-syntax types into type-checker types and print them
with pretty type variables.

Generate constraints for let-expressions using type annotations.

Build test function to turn strings into type constraints.
Remove the old type-checker code.
Start adding constraint generation for declarations.
Create a Type.Pool module specifically for variable pools. Start using
a state transformer to thread the pool and errors through.
Update changelog for pretty printing
Create type pools, have an organized model of state to flow through
the State Transformer during constraint solving and variable unification.
Get the solver working on basic programs. It outputs pretty types for the
variables in the program. Need to test further and start doing some benchmarking.
Make pretty printing properly parenthesize higher order functions.
Not the best implementation, but it is simple and works well.