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:     Out1_2 = [1,2],
      Tst1_3 = {':', [<<"a">>, {'[]', <<"b">>, [1,2,3]}]}, % a:b[1,2,3]
      Tst1_3b = {':', [<<"a">>, <<"b">>]}, % a:b[1,2,3]
      Out1_3 = [[{<<"c">>,1}],[{<<"c">>,2}],[{<<"c">>,3}]],
      Tst1_4 = {':', [<<"a">>, {'[]', <<"b">>, []}, <<"c">>]}, % a:b[]:c
      Out1_4 = [1,2,3],
  
      Object2 = <<"{\"a\" : {\"b\" :{\"any\":{\"c\":1,\"d\":2},\"c\":{\"c\":4,\"d\":2}}}}">>,
      Tst2_1 = {':', [<<"a">>, {'{}', <<"b">>, []}, <<"c">>]}, % a:b{}:c
      Out2_1 = [1,4],
      Tst2_2 = {':', [<<"a">>, {'{}', <<"b">> ,[<<"c">>]}]}, %a:b{c}
      Out2_2 = [[{<<"c">>,4},{<<"d">>,2}]],
      Tst2_3 = {':', [<<"a">>, <<"b">>, {'$',<<"values">>}, <<"c">>]}, % a:b:$values$:c
      Out2_3 = [1,4],
  
      Object3 = <<"[{\"c\":{\"a\":{\"d\":3}}},{\"c\":{\"b\":{\"d\":2}}}]">>,
      Tst3_1 = {':', [{'[]', '_', []}, {'{}', <<"c">>, {'$',<<"firstChild">>}}, <<"d">>]}, % []:c{$firstChild$}:d
      Out3_1 = [3,2],
  
      {setup,
       fun setup/0,
  
negative.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[1-2,3]",?_assertEqual(Out1_5,jpp_match(Tst1_5,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 a:b{any,c}:d",?_assertEqual(Out2_4,lists:sort(jpp_match(Tst2_4,Object2)))},
       {"form a:b:any:c", ?_assertEqual(Out2_5, jpp_match(Tst2_5,Object2))},
       {"form []:c{$firstChild$}:d",?_assertEqual(Out3_1,jpp_match(Tst3_1,Object3))},
       {"form [1]:d",?_assertEqual(Out3_2,jpp_match(Tst3_2,Object3))},
       {"form []:c:$firstChild$:d",?_assertEqual(Out3_3,jpp_match(Tst3_3,Object3))},
       {"form {c,d}:e",?_assertEqual(Out4_1,jpp_match(Tst4_1,Object4))},
       {"form {a-c}:e",?_assertEqual(Out4_2,jpp_match(Tst4_2,Object4))},
       {"form a:$keys$",?_assertEqual(Out4_3,jpp_match(Tst4_3,Object4))},
       {"form a{$keys$}",?_assertEqual(Out4_4,jpp_match(Tst4_4,Object4))},
       {"form $keys$",?_assertEqual(Out4_5,jpp_match(Tst4_5,Object4))},
       {"form $keys$[1]",?_assertEqual(Out4_6,jpp_match(Tst4_6,Object4))},
       {"form a:b[1-2]{}:c",?_assertEqual(Out5_1,jpp_match(Tst5_1,Object5))},
       {"nomatch a:b[1-3]{}:c",?_assertEqual(nomatch,jpp_match(Tst5_2,Object5))},
       {"nomatch a:z",?_assertEqual(nomatch,jpp_match(Tst5_3,Object5))},
       {"form {}[]{b}",?_assertEqual(Out6_1,jpp_match(Tst6_1,Object6))}
       ]}.
      
  
  