anchor.diff:              | _ -> Failure(sprintf "undefined operator: `%s`" op)
           | List lst -> Failure(sprintf "invalid argument: `%A`" lst)
   
  -type orelangEngine() as this =
  +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"))
  +        do this.def_operator "+" <|
  +            function
  +            | e1::e2::_ ->
  +                match (this.Evaluate(e1), this.Evaluate(e2)) with
  +                | (Success(Number v1), Success(Number v2)) -> Success(Number(v1 + v2))
  +                | _ -> Failure("[+] cannot substitute")
  +            | _ -> Failure("invalid argument")
   
   [<EntryPoint>]
   let main _ =
  
positive.code:     let variables = Dictionary<string, expression>()
      let operators = Dictionary<string, operator>()
  
      member this.Variables = variables
      member this.Operators = operators
  
      member this.Evaluate =
          function
  
negative.code:     // 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
  