anchor.diff:          printfn "☠️ %s" message
           printfn ""
   
  -module Driver =
  -
  -  let [<Literal>] Preamble = "Kaleidoscope in F# and LLVM\n"
  -
  -
  -  // Read user input until an empty line with a return
  -  // TODO: pass in a reader or see if fparsec has stdin support
  -  let readLines scanner =
  -    let rec readLinesIntoSeqAsync lines =
  -      async {
  -        let! nextLine = (scanner: TextReader).ReadLineAsync() |> Async.AwaitTask
  -        if String.IsNullOrEmpty(nextLine) 
  -          then return seq lines
  -          else
  -            do printf "-\t"
  -            return! readLinesIntoSeqAsync (lines @ [ nextLine ])
  -      } 
  -        
  -    seq { 
  -      yield! readLinesIntoSeqAsync [] 
  -        |> Async.RunSynchronously
  -        |> Seq.rev 
  -    } |> String.concat "\n"
  -
  -  // Main entrypoint for the driver  
  -  let run scanner =
  -    do 
  -      printfn "%s" Preamble
  -      let prompt = "ready>\t"
  -      let rec runRepl () =
  -        do 
  -          printf "%s" prompt
  -          let lines = readLines scanner
  -          if String.IsNullOrWhiteSpace(lines) then runRepl ()
  -          let result = Parser.run lines
  -          Parser.showResult result
  -          runRepl ()
  -      runRepl ()
  -
   open LLVMSharp
  -open FParsec
  -open System.Reflection.Metadata.Ecma335
   
   let [<Literal>] JitName = "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
  -
   let context = LLVM.GetGlobalContext()
   let module' = LLVM.ModuleCreateWithNameInContext(JitName, context)
   let builder = LLVM.CreateBuilderInContext(context)
  
positive.code:   open AST
    open Lexer
  
    type UserState = unit
  
    [<RequireQualifiedAccess>]
    module private Expr =
  
negative.code: module Codegen =
  
    open AST
  
    let rec private codegenExpr (namedValues: Map<string, LLVMValueRef>) =
      function
      | Number n -> LLVM.ConstReal(LLVM.DoubleType(), n)
      | Variable name ->
  