anchor.diff:  jpp_match(Tree,DataObject) when is_binary(DataObject) ->
       jpp_match(Tree,?FROM_JSON(DataObject));
   jpp_match(Tree,DataObject) ->
  -    jpp_walk(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
       %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
positive.code:     jpp_walk([],CLevel) -> CLevel;
  
      %% Object Walking
      jpp_walk([Field|Tail],CLevel) when is_binary(Field) ->
          jpp_walk([?OO(Field)| Tail], CLevel);
  
      jpp_walk([?OO([])|Tail],CLevel) ->
          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([?FF(Any)|Tail], CLevel);
  
      jpp_walk([{'{}',Origin,Field}|Tail],CLevel) ->
          jpp_walk([?OO(Origin),?OO(Field) | 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);
  
      %% 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([?OO(Field), ?LL(Index)| Tail], CLevel);
  
      jpp_walk([?LL([])|Tail],CLevel) ->
          jpp_walk([?LL({'-', 1, ?MODULE:size(CLevel)})| Tail], CLevel);
  
      jpp_walk([?LL({'-',Start,End})|Tail],CLevel) ->
          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(Index)| Tail], CLevel) || Index <- List];
          
  
      %% Lower level matching (and actually doing something)
      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
negative.code:             NLevel -> jpp_walk(Tail,NLevel)
          end.
  
      %% Any function-generated value should be dealt with here
      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
      jpp_value(Value) when is_binary(Value) -> Value;
      jpp_value(Value) when is_integer(Value) -> Value.
           
  