anchor.diff:      jpp_walk([],CLevel) -> CLevel;
   
       %% Object Walking
  -    jpp_walk([Field|Tail],CLevel) when is_binary(Field) ->
  +    jpp_walk([Field|Tail],CLevel) when is_binary(Field) -> % <<"field">> => {'{}',<<"field">>}
           jpp_walk([?OO(Field)| Tail], CLevel);
  -
  -    jpp_walk([?OO([])|Tail],CLevel) ->
  +    jpp_walk([{'{}','_',Fields}|Tail],CLevel) when is_list(Fields) -> % {'{}','_',Fields}
  +        jpp_walk([?OO(Fields)|Tail],CLevel);
  +    jpp_walk([{'{}',Origin,Field}|Tail],CLevel) -> % {'{}',O,F} => [{'{}',O}, {'{}',F}]
  +        jpp_walk([?OO(Origin),?OO(Field) | Tail],CLevel);
  +    jpp_walk([?OO([])|Tail],CLevel) -> % {'{}',[]} => {'$',<<"values">>}
           jpp_walk([?FF(<<"values">>)|Tail], CLevel);
  -
  -    jpp_walk([?OO(ManyFields)|Tail],CLevel) when is_list(ManyFields) ->
  -        [jpp_walk([?OO(Field) | Tail],CLevel) || Field <- ManyFields];
  -
  -    jpp_walk([?OO('_')|Tail],CLevel) ->
  -        jpp_walk([Tail], CLevel);
  -
  -    jpp_walk([?OO(?FF(Any))|Tail],CLevel) ->
  +    jpp_walk([?OO(Fields)|Tail],CLevel) when is_list(Fields) -> % {'{}',Fields}
  +        [jpp_walk([?OO(Field) | Tail],CLevel) || Field <- Fields];
  +    jpp_walk([?OO('_')|Tail],CLevel) -> % {'{}','_'}
  +        jpp_walk(Tail, CLevel);
  +    jpp_walk([?OO(?FF(Any))|Tail],CLevel) ->  % {'{}',{'$',any}} => {'$',any}
           jpp_walk([?FF(Any)|Tail], CLevel);
  -
  -    jpp_walk([{'{}',Origin,Field}|Tail],CLevel) ->
  -        jpp_walk([?OO(Origin),?OO(Field) | Tail],CLevel);
  +    jpp_walk([?OO({'-',Start,End})|Tail],CLevel) -> % {'{}',{'-',S,E}}
  +        Keys = lists:foldl(fun(K,Acc) ->
  +                            if K >= Start, K =<  End -> [K|Acc];
  +                            true -> Acc end end,
  +                           [], ?MODULE:keys(CLevel)),
  +        jpp_walk([?OO(lists:reverse(Keys))| Tail], CLevel);
  +    jpp_walk([?OO({'[]',F,I})|Tail],CLevel) -> %{'{}',{'[]',F,I}}
  +        jpp_walk([?OO(F),?LL(I)|Tail],CLevel);
  +    jpp_walk([?OO({'{}',O,F})|Tail],CLevel) -> %{'{}',{'{}',F,I}}
  +        jpp_walk([?OO(O),?OO(F)|Tail], CLevel);
   
       %% Object "Function-as-a-property"
       jpp_walk([?FF(<<"values">>)|Tail],CLevel) ->
           [jpp_walk(Tail,NLevel) || NLevel <- ?MODULE:values(CLevel)];
  -
       jpp_walk([?FF(<<"firstChild">>)|Tail],CLevel) ->
           [NLevel|_] = ?MODULE:values(CLevel),
           jpp_walk(Tail,NLevel);
  +    jpp_walk([?FF(<<"keys">>)|Tail],CLevel) ->
  +        jpp_walk(Tail,?MODULE:keys(CLevel));
   
       %% List Walking
  -    jpp_walk([{'[]','_',Index}|Tail],CLevel) ->
  -        jpp_walk([?LL(Index)|Tail],CLevel);
  -
  -    jpp_walk([{'[]',Field,Index}|Tail],CLevel) when is_binary(Field) ->
  +    jpp_walk([{'[]','_',Index}|Tail],CLevel) -> % {'[]','_',I} => {'[]',I}
  +        jpp_walk([?LL([Index])|Tail],CLevel);
  +    jpp_walk([{'[]',Field,Index}|Tail],CLevel) -> % {'[]',F,I} => [{'{}',F}, {'[]',I}]
           jpp_walk([?OO(Field), ?LL(Index)| Tail], CLevel);
  -
  -    jpp_walk([?LL([])|Tail],CLevel) ->
  +    jpp_walk([?LL([])|Tail],CLevel) -> % {'[]',[]} => {'-',1,Max}
           jpp_walk([?LL({'-', 1, ?MODULE:size(CLevel)})| Tail], CLevel);
  -
  -    jpp_walk([?LL({'-',Start,End})|Tail],CLevel) ->
  +    jpp_walk([?LL({'-',Start,End})|Tail],CLevel) -> % {'[]',{'-',S,E}}
           Seq = lists:seq(?JV(Start), ?JV(End)),
           jpp_walk([?LL(Seq)| Tail], CLevel);
  -
  -
  -    jpp_walk([?LL(List)|Tail], CLevel) when is_list(List) ->
  +    jpp_walk([?LL(List)|Tail], CLevel) when is_list(List) -> % {'[]',[Fields]}
           [jpp_walk([?LL(Index)| Tail], CLevel) || Index <- List];
  -        
   
       %% Lower level matching (and actually doing something)
       %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
positive.code:      {"form a:b[1,2,3]",?_assertEqual(Out1_3,jpp_match(Tst1_3,Object1))},
       {"form a:b",?_assertEqual(Out1_3,jpp_match(Tst1_3b,Object1))},
       {"form a:b[]:c",?_assertEqual(Out1_4,jpp_match(Tst1_4,Object1))},
       {"form a:b{}:c",?_assertEqual(Out2_1,jpp_match(Tst2_1,Object2))},
       {"form a:b{c}",?_assertEqual(Out2_2,lists:sort(jpp_match(Tst2_2,Object2)))},
       {"form a:b:$values$:c}",?_assertEqual(Out2_3,lists:sort(jpp_match(Tst2_3,Object2)))},
       {"form []:c{$firstChild$}:d",?_assertEqual(Out3_1,jpp_match(Tst3_1,Object3))}
       ]}.
      
  
  
negative.code: jpp_match(Tree,DataObject) when is_binary(DataObject) ->
      jpp_match(Tree,?FROM_JSON(DataObject));
  jpp_match(Tree,DataObject) ->
      Out = jpp_walk(Tree,DataObject),
      if is_list(Out) -> Flat = lists:flatten(Out),
                         case lists:any(fun(nomatch) -> true;
                                       (_) -> false end,Flat) of
                             true -> nomatch;
                             false -> Flat
                         end;
         true -> Out
      end.
  
      %% jpp_walk transposes jpparse constructs to simple unary primitives {'{}',Field} and {'[]',Index}.
      %% Whenever a list of fields or indexes is encountered, it just does a mapping, and each field/index
      %% generates it's own match, witch are then grouped together. Code repetition is avoided, and kept terse.
      %%
      %% Here is an example of the jpparse and its ultimate "primitivized" form:
      %%
      %% form {}[]{b}: [{'{}',{'[]',{'{}','_',[]},[]},[<<"b">>]}]
      %%  -> [{'{}',{'[]',{'{}','_',[]},[]}}, {'{}',[<<"b">>}]]
      %%  -> [{'{}',{'{}','_',[]}}, {'[]',[]} | {'{}',[<<"b">>]}]
      %%  -> [{'{}','_'}, {'{}',[]'} | {'[]',[]}, {'{}',[<<"b">>]}]
      %%  -> [{'$',<<"values">>}, {'[]',[]}, {'{}', [<<"b">>]}]
  
      %% Higher level parsing
      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  