anchor.diff:  tokenize_identifier(Rest, Acc, _) ->
     { Rest, { identifier, list_to_atom(lists:reverse(Acc)) } }.
   
  -tokenize_extra_identifier(String, Acc) ->
  +% Tokenize identifier checking if it is a kv_identifier or a call_identifier.
  +tokenize_many_identifier(Line, String, Acc) ->
     { Rest, { Kind, Atom } } = tokenize_identifier(String, Acc),
     case Rest of
  -    [$:|T] -> { T, { kv_identifier, Atom } };
  -    [$(|_] -> { Rest, { paren_identifier, Atom } };
  +    [$:|T] ->
  +      { T, { kv_identifier, Line, Atom } };
  +    _ ->
  +      { Rest, tokenize_call_identifier(Kind, Line, Atom, Rest) }
  +  end.
  +
  +% Tokenize identifier checking if it is a call_identifier.
  +tokenize_call_identifier(Kind, Line, Atom, Rest) ->
  +  case Rest of
  +    [$(|_] -> { paren_identifier, Line, Atom };
       _ ->
         case next_is_do(Rest) of
  -        true  -> { Rest, { do_identifier, Atom } };
  -        false -> { Rest, { Kind, Atom } }
  +        true  -> { do_identifier, Line, Atom };
  +        false -> { Kind, Line, Atom }
         end
     end.
   
  
positive.code: 
  % Atom operators
  
  tokenize(Line, [$:,T|Rest], Tokens) when T == $+; T == $-; T == $*; T == $/; T == $= ->
    tokenize(Line, Rest, [{atom,Line,list_to_atom([T])}|Tokens]);
  
  tokenize(Line, [$:,T1,T2|Rest], Tokens) when T1 == $& andalso T2 == $&; T1 == $| andalso T2 == $|;
    T1 == $[ andalso T2 == $]; T1 == ${ andalso T2 == $}; T1 == $: andalso T2 == $: ->
    tokenize(Line, Rest, [{atom,Line,list_to_atom([T1,T2])}|Tokens]);
  
  % KV Identifiers
  
  tokenize(Line, [T,$:|Rest], Tokens) when T == $+; T == $-; T == $*; T == $/; T == $= ->
    tokenize(Line, Rest, [{kv_identifier,Line,list_to_atom([T])}|Tokens]);
  
  tokenize(Line, [T1,T2,$:|Rest], Tokens) when T1 == $& andalso T2 == $&; T1 == $| andalso T2 == $|;
    T1 == $[ andalso T2 == $]; T1 == ${ andalso T2 == $}; T1 == $: andalso T2 == $: ->
    tokenize(Line, Rest, [{kv_identifier,Line,list_to_atom([T1,T2])}|Tokens]);
  
  % Call operators
  
  tokenize(Line, [$.,$(|Rest], Tokens) ->
    tokenize(Line, [$(|Rest], [{dot_call_op,Line,'.'}|Tokens]);
  
  tokenize(Line, [T,$(|Rest], Tokens) when T == $+; T == $-; T == $*; T == $/; T == $= ->
    tokenize(Line, [$(|Rest], [{call_op,Line,list_to_atom([T])}|Tokens]);
  
  tokenize(Line, [T1,T2,$(|Rest], Tokens) when T1 == $& andalso T2 == $&; T1 == $| andalso T2 == $|;
    T1 == $[ andalso T2 == $]; T1 == ${ andalso T2 == $}; T1 == $: andalso T2 == $: ->
    tokenize(Line, [$(|Rest], [{call_op,Line,list_to_atom([T1,T2])}|Tokens]);
  
  % Ambiguous unary/binary operators tokens
  
  
negative.code:   Rest = [NotMarker|T],
    tokenize(Line, Rest, [{special_op,Line,list_to_atom([Sign])}|Tokens]);
  
  % Stand-alone tokens
  
  % ## Containers + punctuation tokens
  tokenize(Line, [T|Rest], Tokens) when T == $(;
    T == ${; T == $}; T == $[; T == $]; T == $|;
    T == $); T == $,; T == $. ->
    tokenize(Line, Rest, [{list_to_atom([T]), Line}|Tokens]);
  
  % ## Two Token Operators
  tokenize(Line, [T1,T2|Rest], Tokens) when T1 == $: andalso T2 == $:;
    T1 == $& andalso T2 == $&; T1 == $| andalso T2 == $| ->
    tokenize(Line, Rest, [{list_to_atom([T1,T2]), Line}|Tokens]);
  
  % ## Single Token Operators
  tokenize(Line, [T|Rest], Tokens) when T == $+; T == $-; T == $*; T == $/; T == $= ->
    tokenize(Line, Rest, [{list_to_atom([T]), Line}|Tokens]);
  
  % References
  
  tokenize(Line, [H|_] = String, Tokens) when H >= $A andalso H =< $Z ->
  