Initial 1st pass of compiler can handle:
Enums - as fully as I'd like to
Interfaces - with methods with no parameters and predetermined return types
classes - can simply build the type
Added intermediate compile step to build TypeBuilders with the bodies, rather than abstract names.
Hopefully this will make using them as Types in method bodies easier.
Add support for parameter lists in method definitions.
Add the amility for classes to have a body and some content.

Can currently call static methods on any type in mscorlib, so long as it takes strings as parameters
Move some preprocessing of Ast from compiler to PreCompileAst - namely computing types.
Add some recognizers to lex and yacc for defining fields and locals
Can now define local variables (not ints for some reason), and use them in method calls
Can now + Expressions which is pretty cool

List of key things to do
Rename PreCompileAst to TypedAst
Call instance methods
Determine how to call fields vs locals
PreCompileAst renamed to TypedAst
Can now resolve non-mscorlib types (so long as they are referenced by compiler) and get them from using clauses

TODO:
Typed Expr Ast
Add referenced assemblies
Instance calls
Added Typed Ast Expr, realized Call should use MethodInfo so I can get return types

Can now load assemblies, albeit with a deprecated call, also some timing operations.

TODO: Resolve method info - this may involve building stubs for methods in typebuilder in TypedAst. Compiler is turning into IL Compiler, which is fine I guess.
Add the ability to create new objects using the default constructor and return values from a method.

Next - MethodInfo and static/instance calls.
Made the sample more broken down into specific usages for demo purposes
Added comments
Added actual recognition of true/false/integers/floats

TODO (Still)
Static/Instance calls
use parameters (as locals?)
Removing comments as they didnt work so well. They kind of ate all the code.
TCall now calls a MethodInfo which enables us to remove the cascading using clauses and type info is now strictly contained in the TypedAst.fs file
Added the ability to infer types from the Expression, and use that to determine method overloads :)
Improved Parser so that Expr deal with all ; cases, which was simply broken before.
Made void methods types infer to None for consistency
Can now call instance methods (except this) and improved quoted string recognition as well as a compiler DSL (because who doesnt love DSLs?)
Added equality tests so I can do ifs next
Implemented If and lexical scope. Seems to be OK.