anchor.diff:          | Failure e -> Failure e
   
   
  -type expression = Boolean of bool
  +type expression = Nil
  +                | Boolean of bool
                   | Number of int
                   | Symbol of string
                   | List of expression list
  
positive.code:     let variables = Dictionary<string, expression>()
      let operators = Dictionary<string, operator>()
  
      member this.Evaluate =
          function
          | Nil -> Success(Nil)
  
negative.code:             | (true, v) -> Success(v)
              | _ -> Failure(sprintf "undefined symbol: `%s`" s)
  
          | List [] -> Failure("need one or more elements in the list")
          | List(Symbol(op) :: args) ->
              match operators.TryGetValue(op) with
              | (true, op) -> op.Invoke(args)
              | _ -> Failure(sprintf "undefined operator: `%s`" op)
          | List lst -> Failure(sprintf "invalid argument: `%A`" lst)
  
  type orelangEngine() as this =
      inherit engine()
      with
          do this.Operators.Add("+", fun args ->
                                     match args with
                                     | e1::e2::_ ->
                                       match (this.Evaluate(e1), this.Evaluate(e2)) with
                                       | (Success(Number v1), Success(Number v2)) -> Success(Number(v1 + v2))
                                       | _ -> Failure("[+] cannot substitute")
                                     | _ -> Failure("not implemented"))
  
  [<EntryPoint>]
  let main _ =
      // printfn "%A" <| Parser.FromString "hoge"
      // printfn "%A" <| Parser.FromString "10"
      // printfn "%A" <| Parser.FromString "-10"
      // printfn "%A" <| Parser.FromString "false"
      // printfn "%A" <| Parser.FromString "(a b c + - * / _ !)"
      // printfn "%A" <| Parser.FromString "(abc/def a10 (2 3 hoge))"
      // printfn "%A" <| Parser.FromString "( 10 fa1   \n 10  )"
  
      // printfn "%A" <| Parser.FromString "(10a)"
      // printfn "%A" <| Parser.FromString "a b c"
  
      let eng = orelangEngine()
      Parser.FromString "(+ 1 2)" |> Result.bind eng.Evaluate |> printfn "%A"
      0
  