anchor.diff:    compare_struct(body, E, A, "{{_}}").
   
   %% Compare non-empty JSON structured types; defer to simple comparison otherwise
  -compare_struct(_, E = [{_,_}|_], A = [{_,_}|_], _Unexpected)           ->
  +compare_struct(_, E0 = [{_,_}|_], A = [{_,_}|_], _Unexpected)           ->
  +  Unexpected = proplists:get_value("{{_}}", E0, "{{_}}"),
  +  E = proplists:delete("{{_}}", E0),
     Keys = lists:usort([K || {K, _} <- lists:merge(A, E)]),
  -  Unexpected = proplists:get_value("{{_}}", E, "{{_}}"),
     [ compare_struct(K, proplists:get_value(K, E), proplists:get_value(K, A), Unexpected)
       || K <- Keys
     ];
  
positive.code:     || {E, A} <- lists:zip(E0, A0)
    ];
  compare_struct(K, E = [[_|_]|_], A = [[_|_]|_], _Unexpected)           ->
    Unexpected = "{{disallow}}",
    compare_struct(K, enumerate(E, K), enumerate(A, K), Unexpected);
  compare_struct(K, E, A, Unexpected) ->
    compare(K, E, A, Unexpected).
  
  %% Compare when unexpected values show up
  compare(_Key, undefined, _A, ?MATCH_ANY) ->
    pass;
  compare(_Key, undefined, _A, undefined)  ->
    pass;
  compare(Key, undefined, A, Unexpected)   ->
    compare(Key, Unexpected, A);
  compare(Key, E, A, _Unexpected)          ->
  
negative.code: 
  
  %% Compare JSON primitive types or empty structured types
  compare(Key, E, undefined)                 ->
    {undefined, {Key, E, undefined}};
  compare(_Key, ?MATCH_ANY ++ _, _)          ->
    pass;
  compare(_Key, ?STORE_BEGIN_TAG ++ Rest, A) ->
  