anchor.diff:  
       member this.print() = printfn "env: %A" env
   
  +let testEval expr =
  +    match expr with
  +    | Result.Error msg -> printfn "failed to parse: %A\n" msg
  +    | Result.OK expr ->
  +        let engine = engine().Default()
  +        printfn "result: %A" <| engine.Evaluate expr
  +
  +let testString s =
  +    printfn "\nstring: %s" s
  +    testEval <| Parser.ParseFromString s
  +
  +let testFile filename =
  +    printfn "\nfile: %s" filename
  +    let repo_root = Directory.GetParent(__SOURCE_DIRECTORY__).ToString()
  +    testEval (Parser.ParseFromFile <| repo_root + "/examples/" + filename)
  +
   [<EntryPoint>]
   let main _ =
  -    let testEval expr =
  -        match expr with
  -        | Result.Error msg -> printfn "failed to parse: %A\n" msg
  -        | Result.OK expr ->
  -            let engine = engine().Default()
  -            printfn "result: %A" <| engine.Evaluate expr
  -
  -    let testString s =
  -        printfn "\nstring: %s" s
  -        testEval <| Parser.ParseFromString s
  -
  -    let testFile filename =
  -        printfn "\nfile: %s" filename
  -        let repo_root = Directory.GetParent(__SOURCE_DIRECTORY__).ToString()
  -        testEval (Parser.ParseFromFile <| repo_root + "/examples/" + filename)
  -
       testString "nil"
       testString "(+ 1 2 (* 3 4))"
       testString "(set i 10)"
  
positive.code: and operator_t = delegate of expr list -> expr option
  
  module Expr =
      let ToBoolean e =
          match e with
          | Boolean b -> Some b
          | _ -> None
  
      let ToNumber e =
          match e with
          | Number d -> Some d
          | _ -> None
  
      let ToSymbol e =
          match e with
          | Symbol s -> Some s
          | _ -> None
  
  module Parser =
      open FParsec
      open FParsec.Primitives
      open FParsec.CharParsers
      open System
  
      type Result = Result
  
      let private nil = pstring "nil" >>% Nil
      let private number = regex "[+-]?[0-9]+" |>> (Int32.Parse >> Number)
  
negative.code: 
      let private expr = fix <| fun expr -> token <|> command expr
  
      let ParseFromString s =
          let parser = spaces >>. expr .>> spaces .>> eof
          match run parser s with
          | Success(r, _, _) -> Result.OK r
          | Failure(msg, _, _) -> Result.Error msg
  
      let ParseFromFile path =
          ParseFromString <| System.IO.File.ReadAllText path
  
  type engine() =
  