anchor.diff:      printfn "%A" <| Parser.FromString "a b c"
   
       let eng = engine()
  -    Parser.FromString "(+ 1 2)" |> eng.Evaluate |> printfn "%A"
  +    Parser.FromString "(+ 1 2)" |> Result.bind eng.Evaluate |> printfn "%A"
       0
  
positive.code:     let symbol = regex @"[a-zA-Z\+\-\*\/!_][a-zA-Z0-9\+\-\*\/!_]*" |>> Symbol
  
      let list expr =
          brackets <| spaces >>. sepEndBy expr spaces1 .>> spaces |>> List
  
      let expression = fix <| fun expr ->
          boolean <|> number <|> symbol <|> list expr
  
negative.code: type operator = delegate of expression list -> result<expression, string>
  
  type engine() =
      let variables = Dictionary<string, expression>()
      let operators = Dictionary<string, operator>()
  
      member this.Evaluate = function
      | Boolean(b) -> Success(Boolean(b))
      | Number(n) -> Success(Number(n))
      | Symbol(s) ->
          match variables.TryGetValue(s) with
          | (true, v) -> Success(v)
          | _ -> Failure(sprintf "undefined symbol: `%s`" s)
  
      | List(Symbol(op) :: args) ->
          match operators.TryGetValue(op) with
          | (true, op) -> op.Invoke(args)
          | _ -> Failure(sprintf "undefined operator: `%s`" op)
  
  
  [<EntryPoint>]
  