anchor.diff:                }
               | _ -> Failure("invalid argument")
   
  +        do this.def_operator "step" <|
  +            fun expr ->
  +                expr
  +                |> List.map (this.Evaluate)
  +                |> List.fold (fun acc e -> acc |> Result.bind (fun _ -> e)) (Success Nil)
  +
  +        do this.def_operator "set" <|
  +            function
  +            | Symbol(sym) :: e :: _ ->
  +                e |> this.Evaluate |> Result.map (fun e -> this.put_variable sym e; Nil)
  +            | _ -> Failure ("[set] invalid arguments")
  +
  +        do this.def_operator "until" <|
  +            function
  +            | pred :: expr -> eval_until pred expr Nil
  +            | _ -> Failure("invalid arguments")
  +
  +        do this.def_operator "print" <|
  +            function
  +            | hd :: _ -> printfn "[print] %A" (this.Evaluate hd); Success(Nil)
  +            | _ -> Success(Nil)
  +
   [<EntryPoint>]
   let main _ =
       // printfn "%A" <| Parser.FromString "hoge"
  
positive.code:     // printfn "%A" <| Parser.FromString "a b c"
  
      let eng = OrelangEngine()
      Parser.FromString "(+ 1 2)" |> Result.bind eng.Evaluate |> printfn "%A"
      0
  
negative.code: 
      let number = regex @"[\+\-]?\d+" |>> (Int32.Parse >> Number)
  
      let symbol = regex @"[a-zA-Z\+\-\*\/!_=][a-zA-Z0-9\+\-\*\/!_=]*" |>> Symbol
  
      let list expr =
          brackets <| (spaces >>. sepEndBy expr spaces1 .>> spaces |>> List)
  