anchor.diff:  -type value() :: term().
   -type key() :: binary().
   
  +-ifdef(TEMP_ALLOW_MATCH).
  +-type match_object() :: list() | map() | binary().
  +-type match_pos() :: str_start | bin_start | str_end | bin_end.
  +-type match_expression() :: {match_pos(),match_pos(),binary()}.
  +-endif.
   %% ===================================================================
   %% Exported functions
   %% ===================================================================
  
positive.code:     is_disjoint(?FROM_JSON(DataObject1), ?FROM_JSON(DataObject2)).
  -endif.
  
  
  %% ===================================================================
  %% Internal functions
  
negative.code:     ?TO_JSON(clean_null_values(?FROM_JSON(DataObject))).
  -endif.
  
  
  -ifdef(TEMP_ALLOW_MATCH).
  %% @doc Returns true if provided binary matches binary match expression
  -spec binary_match(binary(),match_expression() | binary()) -> boolean().
  binary_match(Binary,{_,_,Binary}) -> true;
  binary_match(_,{bin_start,bin_start,<<"">>}) -> true;
  binary_match(<<"">>,{bin_start,bin_end,<<"">>}) -> true;
  binary_match(_,{bin_start,bin_end,<<"">>}) -> false;
  binary_match(Bin,{bin_start,str_end,Match}) ->
      WalkFun = fun(M,_,M) -> true;
                   (<<_,R/binary>>,F,M) -> F(R,F,M);
                   (_,_,_) -> false end,
      WalkFun(Bin,WalkFun,Match);
  binary_match(Bin,{str_start,bin_end,Match}) ->
      Size = byte_size(Match),
      case Bin of
          <<Match:Size/bytes,_/binary>> -> true;
         _ -> false
      end;
  binary_match(Bin,{bin_start,bin_end,Match}) ->
      Size = byte_size(Match),
      WalkFun = fun (<<M:Size/bytes,_/binary>>,_,M) -> true;
                   (<<_,R/binary>>,F,M) -> F(R,F,M);
                   (_,_,_) -> false end,
      WalkFun(Bin,WalkFun,Match);
  binary_match(_,{_,_,_}) -> false;
  binary_match(Binary,MatchBin) -> binary_match(Binary,parse_match(MatchBin)).
  
  
  %% @doc Parse a binary into a imem_json binary match expression
  -spec parse_match(binary()) -> match_expression().
  parse_match(Bin) -> parse_match(Bin,{undefined,undefined,undefined}).
  
  -spec parse_match(binary(),match_expression()) -> match_expression().
  parse_match(<<"">>,{undefined,undefined,undefined}) -> {bin_start,bin_end,<<"">>};
  parse_match(<<"*">>,{undefined,undefined,undefined}) -> {bin_start,bin_start,<<"">>};
  parse_match(<<"*",Rem/binary>>,{undefined,undefined,_}) ->
      parse_match(Rem,{bin_start,undefined,<<"">>});
  parse_match(<<Rem/binary>>,{undefined,undefined,_}) ->
      parse_match(Rem,{str_start,undefined,<<"">>});
  parse_match(<<>>,{Begin,undefined,Acc}) ->
      {Begin,str_end,Acc};
  parse_match(<<"*">>,{Begin,undefined,Acc}) ->
      {Begin,bin_end,Acc};
  parse_match(<<H,Rem/binary>>,{Begin,undefined,Acc}) ->
      parse_match(Rem,{Begin,undefined,<<Acc/binary,H>>}).
  -endif.
      
  
  %% ===================================================================
  %% JSON Binary Handling Power Functions
  %% ===================================================================
  %
  %binary_include(Keys,DataObject) ->
  %    binary_include_walking(walking,DataObject,Keys,<<"">>,{undefined,undefined}).
  %    
  %    binary_include_walking(walking,_,[],<<"">>,_) -> <<"">>;
  %    binary_include_walking(walking,_,[],GroupAcc,_) -> <<GroupAcc/binary,"}">>;
  %    binary_include_walking(walking,<<"">>,_,<<"">>,_) -> <<"">>;
  %    binary_include_walking(walking,<<"">>,_,GroupAcc,_) -> <<GroupAcc/binary,"}">>;
  %
  %    binary_include_walking(walking,<<"{\"",R/binary>>,Keys,<<"">>,_) ->
  %        binary_include_walking(reading_key,R,Keys,<<"">>,{<<"">>,<<"">>});
  %       
  %    binary_include_walking(walking,<<",\"",R/binary>>,Keys,GroupAcc,_) ->
  %        binary_include_walking(reading_key,R,Keys,GroupAcc,{<<"">>,<<"">>});
  %    binary_include_walking(walking,<<_,R/binary>>,Keys,GroupAcc,TAcc) ->
  %        binary_include_walking(walking,R,Keys,GroupAcc,TAcc);
  %
  %    binary_include_walking(reading_key,<<"\":",R/binary>>,Keys,GroupAcc,{KeyAcc,_}) ->
  %        case lists:member(KeyAcc,Keys) of
  %            true -> binary_include_walking(reading_value,R,lists:delete(KeyAcc,Keys),GroupAcc,{KeyAcc,<<"">>});
  %            false -> binary_include_walking(walking,R,Keys,GroupAcc,{undefined,undefined}) end;
  %
  %    binary_include_walking(reading_key,<<H,R/binary>>,Keys,GroupAcc,{KeyAcc,_}) ->
  %        binary_include_walking(reading_key,R,Keys,GroupAcc,{<<KeyAcc/binary,H>>,undefined});
  %
  %    binary_include_walking(reading_value,<<"\"",R/binary>>,Keys,GroupAcc,{KeyAcc,<<"">>}) ->
  %        binary_include_walking(reading_value,R,Keys,GroupAcc,{KeyAcc,<<"">>});
  %    binary_include_walking(reading_value,<<"\"",R/binary>>,Keys,<<"">>,{KeyAcc,ValueAcc}) ->
  %        binary_include_walking(walking,R,Keys,<<"{\"",KeyAcc/binary,"\":\"",ValueAcc/binary,"\"">>,{undefined,undefined});
  %    binary_include_walking(reading_value,<<"\"",R/binary>>,Keys,GroupAcc,{KeyAcc,ValueAcc}) ->
  %        binary_include_walking(walking,R,Keys,<<GroupAcc/binary,",\"",KeyAcc/binary,"\":\"",ValueAcc/binary,"\"">>,{undefined,undefined});
  %    binary_include_walking(reading_value,<<"[",R/binary>>,Keys,<<"">>,{KeyAcc,<<"">>}) ->
  %        {NewR,ValueAcc} = binary_include_walking_catch_list(R,<<"[">>,1),
  %        binary_include_walking(walking,NewR,Keys,<<"{\"",KeyAcc/binary,"\":\"",ValueAcc/binary,"\"">>,{undefined,undefined});
  %    binary_include_walking(reading_value,<<"[",R/binary>>,Keys,GroupAcc,{KeyAcc,<<"">>}) ->
  %        {NewR,ValueAcc} = binary_include_walking_catch_list(R,<<"[">>,1),
  %        binary_include_walking(walking,NewR,Keys,<<GroupAcc/binary,",\"",KeyAcc/binary,"\":\"",ValueAcc/binary,"\"">>,{undefined,undefined});
  %    binary_include_walking(reading_value,<<H,R/binary>>,Keys,GroupAcc,{KeyAcc,ValueAcc}) ->
  %        binary_include_walking(reading_value,R,Keys,GroupAcc,{KeyAcc,<<ValueAcc/binary,H>>}).
  %
  %    binary_include_walking_catch_list(<<"]",R/binary>>,Acc,0) -> {R,<<Acc/binary,"]">>};
  %    binary_include_walking_catch_list(<<"]",R/binary>>,Acc,Level) ->
  %        binary_include_walking_catch_list(R,<<Acc/binary,"]">>,Level-1);
  %    binary_include_walking_catch_list(<<"[",R/binary>>,Acc,Level) ->
  %        binary_include_walking_catch_list(R,<<Acc/binary,"[">>,Level+1);
  %    binary_include_walking_catch_list(<<H,R/binary>>,Acc,Level) ->
  %        binary_include_walking_catch_list(R,<<Acc/binary,H>>,Level).
  %
  %% ===================================================================
  %% TESTS
  %% ===================================================================
  