anchor.diff:          | Success s -> f s
           | Failure e -> Failure e
   
  +    let ok_or f x =
  +        match x with
  +        | Some x -> Success x
  +        | None -> Failure f
  +
  +
  +type EitherBuilder() =
  +    member this.Bind(x, f) = Result.bind f x
  +    member this.Return(x) = Success x
  +
  +let either = new EitherBuilder()
  +
   
   type expression = Nil
                   | Boolean of bool
                   | Number of int
                   | Symbol of string
                   | List of expression list
  +
  +module Expression =
  +    let ToNumber e =
  +        match e with
  +        | Number n -> Some n
  +        | _ -> None
   
   
   module Parser =
  
positive.code:     with
          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>]
  
negative.code:             | (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)
  
          | List lst -> Failure(sprintf "invalid argument: `%A`" lst)
  
  type OrelangEngine() as this =
  