anchor.diff:  type OrelangEngine() as this =
       inherit engine()
       with
  +        let rec eval_until pred expr res =
  +            pred
  +            |> this.Evaluate
  +            |> Result.bind (function
  +                            | Boolean(true) -> Success(res)
  +                            | _ ->
  +                                expr
  +                                |> List.map this.Evaluate
  +                                |> List.fold (fun acc e  -> acc |> Result.bind (fun _ -> e)) (Success(Nil))
  +                                |> Result.bind (fun res -> eval_until pred expr res))
  +
           do this.def_operator "+" <|
               function
               | e1::e2::_ -> either {
  
positive.code:         operators.Add(name, operator(op))
  
      member this.put_variable name expr =
          variables.Add(name, expr)
  
      member this.Evaluate =
  
negative.code:         | ParserResult.Success (res, _, _) -> result.Success res
          | ParserResult.Failure (msg, _, _) -> result.Failure msg
  
      let FromFile (path:string) =
          try FromString (System.IO.File.ReadAllText path)
          with | :? System.IO.IOException as ex -> result.Failure (ex.Message)
  
  type operator = delegate of expression list -> result<expression, string>
  
  