anchor.diff:      
   matching_array_elements(CompKey, List) ->
       lists:filter(fun(E) -> matching_element(CompKey, E) end, List).
  -
       
  -matching_prefix(Prefix, V) ->
  -    PrefixSize = byte_size(Prefix),
  -    case V of
  -        <<Prefix:PrefixSize/binary, _/binary>> -> true;
  -        _ -> false
  -    end.
  -
       
  -matching_element({K, V}, {struct, E}) ->
  +matching_element({K, V}, E)
  +        when is_list(E)  ->
       Value = as_binary(V),
       case lists:keyfind(as_binary(K), 1, E) of
         false      -> false;
  
positive.code: %%%%% ------------------------------------------------------- %%%%%
  
  
  get(Key, Json) ->
  	get(Key, Json, undefined).
  
  
  get({}, _Json, Default) ->
  	Default;
  	
  get(Keys, Json, Default)
  		when is_tuple(Keys)  ->
  	get(tuple_to_list(Keys), Json, Default);
  	
  	
  get([], Json, _Default) ->
  	Json;
  	
  get([Key | Rest], Json, Default) ->	
  	case get_value(Key, Json) of
  		undefined	-> Default
  	;	AValue		-> get(Rest, AValue, Default)
  	end.
  	
  	
  %%%%% ------------------------------------------------------- %%%%%
  
  
  get_value(Key, Obj)
  		when is_list(Key)  ->
      get_value(iolist_to_binary(Key), Obj);
          
          
  get_value(Key, {L})
  		when is_binary(Key); is_tuple(Key)  ->
      get_value(Key, L);
      
  get_value(_Key, null) ->
      undefined;
      
      
  get_value(Key, #{} = Map) ->
  	maps:get(Key, Map, undefined);
      
  get_value(Key, [{_, _} | _T] = PL) ->
      case lists:keyfind(Key, 1, PL) of
          false		-> undefined;
          {_, Return}	-> Return
      end;
      
      
  get_value(_Key, []) ->
      undefined;
  
  
negative.code:       _          -> false
      end;
      
  matching_element(CompKey, {E})
          when is_list(E)  ->
      matching_element(CompKey, E);
      
  matching_element(Key, E) ->
      erlang:error({error_matching_element, {Key, E}}).
  