anchor.diff:  
       let number = regex @"[\+\-]?\d+" |>> (Int32.Parse >> Number)
   
  -    let symbol = regex @"[a-zA-Z\+\-\*\/!_][a-zA-Z0-9\+\-\*\/!_]*" |>> Symbol
  +    let symbol = regex @"[a-zA-Z\+\-\*\/!_=][a-zA-Z0-9\+\-\*\/!_=]*" |>> Symbol
   
       let list expr =
           brackets <| (spaces >>. sepEndBy expr spaces1 .>> spaces |>> List)
  
positive.code:         | ParserResult.Success (res, _, _) -> result.Success res
          | ParserResult.Failure (msg, _, _) -> result.Failure msg
  
  
  type operator = delegate of expression list -> result<expression, string>
  
  
negative.code: 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 {
  