anchor.diff:        env.Remove(k) |> ignore
         env.Add(k, v)
   
  -    member this.evalFunc name args =
  -      match name with
  -      | "set" -> maybe {
  -          let! k = List.tryItem 0 args >>= Expr.ToSymbol
  -          let! v = List.tryItem 1 args >>= this.Evaluate
  -          this.setValue k v
  -          return Nil
  -        }
  -
  -      | "until" ->
  -         let rec f pred expr =
  -           match this.Evaluate pred with
  -           | Some(Boolean true) -> ()
  -           | _ -> this.Evaluate expr |> ignore
  -                  f pred expr
  -         maybe {
  -           let! pred = List.tryItem 0 args
  -           let! expr = List.tryItem 1 args
  -           f pred expr
  -           return Nil
  -         }
  -
  -      | "step" ->
  -        let rec eval_step lines =
  -          let ret = this.Evaluate(List.head lines)
  -          match (List.tail lines) with
  -          | [] -> ret
  -          | tl -> eval_step tl
  -        eval_step args
  -
  -      | "+" ->
  -        args
  -        |> List.fold (fun acc x -> maybe {
  -             let! acc = acc
  -             let! x = x |> this.Evaluate >>= Expr.ToNumber
  -             return acc + x
  -           }) (Some(decimal 0))
  -        |> Option.map Number
  -
  -      | "=" -> maybe {
  -          let! lhs = List.tryItem 0 args >>= this.Evaluate >>= Expr.ToNumber
  -          let! rhs = List.tryItem 1 args >>= this.Evaluate >>= Expr.ToNumber
  -          return Boolean (lhs = rhs)
  -        }
  -
  -      | "print" -> maybe {
  -          let! arg = List.tryItem 0 args >>= this.Evaluate
  -          printfn "%A" arg
  -          return Nil
  -        }
  -
  -      | "quote" -> List.tryHead args
  -
  -      | s -> s |> this.getValue
  -             >>= Expr.ToSymbol
  -             >>= (fun s -> this.evalFunc s args)
  +    member this.evalFunc op args =
  +      this.getValue op >>= (fun op ->
  +        match op with
  +        | Symbol op     -> this.evalFunc op args
  +        | Operator op   -> op.Invoke(args)
  +        | _             -> None)
   
       member this.Evaluate (expr: expr) : expr option =
         match expr with
         | Nil | Boolean _ | Number _  -> Some expr
         | Symbol k                    -> this.getValue k
  -      | Function (name, args)       -> this.evalFunc name args
  +      | Call (name, args)           -> this.evalFunc name args
  +      | Operator _                  -> Some expr
   
       member this.print() =
         printfn "env: %A" env
  
positive.code: 
    type expr = Nil
              | Boolean of bool
              | Number of decimal
              | Symbol of string
              | Function of string * expr list
  
    module Expr =
      let ToBoolean e =
  
negative.code:     | Result.OK expr ->
        let engine = Orelang.Engine()
        printfn "result: %A" <| engine.Evaluate expr
  
    let testString s =
      printfn "\nstring: %s" s
  