anchor.diff:  handle_dot([$.|Rest], Line, Column, DotColumn, Scope, Tokens) ->
     tokenize(Rest, Line, Column + 1, Scope, add_token_with_nl({'.', {Line, DotColumn, DotColumn + 1}}, Tokens)).
   
  -handle_call_identifier(Rest, Line, Column, DotColumn, Op, Scope, Tokens) ->
  -  {_, {_, _, NewColumn}, _} = Token = check_call_identifier(identifier, Line, Column, Op, Rest),
  -  tokenize(Rest, Line, NewColumn, Scope, [Token|add_token_with_nl({'.', {Line, DotColumn, DotColumn + 1}}, Tokens)]).
  +handle_call_identifier(Rest, Line, Column, DotColumn, Length, Op, Scope, Tokens) ->
  +  {_, {_, _, NewColumn}, _} = Token = check_call_identifier(identifier, Line, Column, Length, Op, Rest),
  +  tokenize(Rest, Line, NewColumn, Scope,
  +           [Token|add_token_with_nl({'.', {Line, DotColumn, DotColumn + 1}}, Tokens)]).
   
   % ## Ambiguous unary/binary operators tokens
   handle_space_sensitive_tokens([Sign, NotMarker|T], Line, Column, Scope, [{Identifier, _, _} = H|Tokens]) when
  
positive.code: 
  % ## Two Token Operators
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?two_op(T1, T2) ->
    handle_op(Rest, Line, Column, two_op, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?arrow_op(T1, T2) ->
    handle_op(Rest, Line, Column, arrow_op, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?comp_op2(T1, T2) ->
    handle_op(Rest, Line, Column, comp_op, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?rel_op2(T1, T2) ->
    handle_op(Rest, Line, Column, rel_op, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?and_op(T1, T2) ->
    handle_op(Rest, Line, Column, and_op, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?or_op(T1, T2) ->
    handle_op(Rest, Line, Column, or_op, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?in_match_op(T1, T2) ->
    handle_op(Rest, Line, Column, in_match_op, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?type_op(T1, T2) ->
    handle_op(Rest, Line, Column, type_op, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?stab_op(T1, T2) ->
    handle_op(Rest, Line, Column, stab_op, list_to_atom([T1, T2]), Scope, Tokens);
  
  % ## Single Token Operators
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?at_op(T) ->
    handle_unary_op(Rest, Line, Column, at_op, list_to_atom([T]), Scope, Tokens);
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?capture_op(T) ->
    handle_unary_op(Rest, Line, Column, capture_op, list_to_atom([T]), Scope, Tokens);
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?unary_op(T) ->
    handle_unary_op(Rest, Line, Column, unary_op, list_to_atom([T]), Scope, Tokens);
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?rel_op(T) ->
    handle_op(Rest, Line, Column, rel_op, list_to_atom([T]), Scope, Tokens);
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?dual_op(T) ->
    handle_unary_op(Rest, Line, Column, dual_op, list_to_atom([T]), Scope, Tokens);
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?mult_op(T) ->
    handle_op(Rest, Line, Column, mult_op, list_to_atom([T]), Scope, Tokens);
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?match_op(T) ->
    handle_op(Rest, Line, Column, match_op, list_to_atom([T]), Scope, Tokens);
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?pipe_op(T) ->
    handle_op(Rest, Line, Column, pipe_op, list_to_atom([T]), Scope, Tokens);
  
  % Others
  
  
negative.code: 
  keyword(_) -> false.
  
  invalid_character_error(Char) ->
    "invalid character '" ++ [Char] ++ "' in identifier: ".
  