anchor.diff:              {command, p};
           {match, ["q", ""]} ->
               {command, q};
  +        {match, ["t", ""]} ->
  +            {command, time};
  +        {match, ["t", Expr]} ->
  +            {command, {time_expr, Expr}};
           {match, ["c", OnOff]} ->
               case string:strip(OnOff) of
                   "on"++ _ ->
                       {command, cache_on};
  -                 "off" ++ _ ->
  -                     {command, cache_off};
  -                 _ ->
  -                     {command, print_cache_state}
  -             end;
  +                "off" ++ _ ->
  +                    {command, cache_off};
  +                _ ->
  +                    {command, print_cache_state}
  +            end;
           {match, ["l", File]} ->
               {command, {l, File}};
           {match, [C|_]} ->
  
positive.code:             do_line(L ++ Line, S)
      end.
  
  do_line(L, #state{defs = Defs, cache = C} = S) ->
      try check_line(L) of
          empty ->
              S;
  
negative.code:     [io:format("~s: ~p\n", [Name, Def]) || {Name, Def} <- Defs],
      ok.
  
  do_query(Q, #state{defs = Defs, cache = C} = S, TC) ->
      try
          QQ = expr_where_defs(Q, Defs),
          case TC of
              no_tc ->
                  {Res, _} = eval(QQ,C),
                  io:format("~p\n", [Res]);
              tc ->
                  {US, {R, _}} = timer:tc(fun() -> eval(QQ,C) end),
                  io:format("(~fs) ~p\n", [US/1000/1000, R])
          end,
          S
      catch
          Class:Err ->
              io:format("*** ~p:~p in ~p\n~p\n",
                        [Class, Err, Q, erlang:get_stacktrace()]),
              catch ice_cache:delete(),
              S#state{cache = clear}
      end.
  
  eval(AST, C) ->
      case C of
          clear ->
  