anchor.diff:      let builder = LLVM.CreateBuilder()
   
       (* Run the main "interpreter loop" now. *)
  -    // tests ()
  +    tests () |> ignore
       Driver.run Console.In
       LLVM.DumpModule(module')
     0
positive.code: 
      override op.ToString() = op.Code
  
  
    (* proto - This type represents the "prototype" for a function, which captures
     * its name, and its argument names (thus implicitly the number of arguments the
     * function takes). *)
    type Prototype = Prototype of String
  
    (* func - This type represents a function definition itself. *)
    type Function = Function of Prototype: Prototype * Body: Expr
  
  module Lexer =
    open FParsec
    open Token
    
    let parseLeftParen = pstring LeftParen
  
    let parseRightParen = pstring RightParen
  
    let parseComma = pstring Comma
    let isSymbolicOperatorChar = isAnyOf SpecialCharacters
    let remainingOperatorCharsAndWhiteSpace = manySatisfy isSymbolicOperatorChar .>> spaces
  
    let parseWhiteSpace = spaces
  
    let parseBetweenBrackets = between parseLeftParen parseRightParen
  
  module Parser =
    open FParsec
    open AST
    open Lexer
  
    type private AST.Operator with
    
      member op.Precedence =
        match op with
        | Plus -> 20
        | LessThan -> 10
        | Minus -> 30
        | Multiply -> 40
  
      member op.Associativity =
        match op with
        | Plus -> Associativity.Left
        | _ -> Associativity.Left
  
    type UserState = unit
  
    let parseExpr, parseExprRef = createParserForwardedToRef<Expr, _>()
  
    let parseValue =
  
      let parseNumber : Parser<Expr, UserState> = pfloat .>> spaces |>> Number
  
      let parseVariable : Parser<Expr, UserState> = 
        let options = IdentifierOptions()
        let parseIdentifierWithOptions = identifier options
        parseIdentifierWithOptions .>> spaces |>> Variable
  
      let parseCall =
        let parseArgs =
          let parseExprs = sepBy parseExpr parseComma
          between parseLeftParen parseRightParen parseExprs
        let operator = parseVariable
        operator .>>. parseArgs |>> (fun (fn, args) -> 
          let (Variable name) = fn
          Call(name, args)
        )
  
      choice [
        parseNumber
        attempt parseCall
        attempt parseVariable
      ]
    
    let addSymbolicInfixOperators (op : Operator) opp =
      let operator = 
        InfixOperator(
          op.Code,
          remainingOperatorCharsAndWhiteSpace,
          op.Precedence,
          op.Associativity,
          (),
          fun _ lhs rhs ->
            BinaryOperation(op, lhs, rhs)
      )
      (opp : OperatorPrecedenceParser<_, _, _>).AddOperator(operator)
    
    let operatorPrecendenceParser = 
      let parseTerm = 
        parseValue .>> parseWhiteSpace
        <|> parseBetweenBrackets parseExpr
      let opp = OperatorPrecedenceParser()
      do 
        opp.TermParser <- parseTerm
        addSymbolicInfixOperators LessThan opp
        addSymbolicInfixOperators Plus opp
        addSymbolicInfixOperators Minus opp
        addSymbolicInfixOperators Multiply opp
      opp
  
    let parseBinaryOperation = operatorPrecendenceParser.ExpressionParser
  
    do parseExprRef := parseBinaryOperation
         
    let showResult = 
      function
      | Success(result, _, _) ->
  
negative.code:       runRepl ()
  
  open LLVMSharp
  open FParsec
  
  let [<Literal>] ``my-cool-jit`` = "my cool jit"
  
  let tests () = 
    [
      // "def foo(x y) x+foo(y, 4.0);"
      // "def foo(x y) x+y y;"
      // "def foo(x y) x+y );"
      "extern sin(a);"
    ]
    |> Seq.map (fun program ->
      async {
        let result = Parser.run program
        match result with
        | Success(tree, _,_) -> printfn "%A" tree
        | Failure(errorMessage, _, _) -> failwith errorMessage
      })
    |> Async.Parallel
    |> Async.RunSynchronously
  
  
  [<EntryPoint>]
  