anchor.diff:  
   %--- Tests --------------------------------------------------------------------
   
  -util_test_() ->
  +deep_find_test_() ->
       {inparallel, [
  -        % Find
           ?_assertEqual({ok, 1},             deep_find([a, a, a], ?STRUCT)),
  -        ?_assertEqual(error,               deep_find([a, b, a], ?STRUCT)),
  -        % Get
  -        ?_assertEqual(1,                   deep_get([a, a, a], ?STRUCT)),
  -        ?_assertEqual(#{a => 1},           deep_get([a, a], ?STRUCT)),
  -        ?_assertEqual(d,                   deep_get([a, c], ?STRUCT, d)),
  -        ?_assertEqual(1,                   deep_get([a, a, a], ?STRUCT, d)),
  -        ?_assertEqual(d,                   deep_get([a, b, c], ?STRUCT, d)),
  -        ?_assertEqual(?STRUCT,             deep_get([], ?STRUCT)),
  -        % Put
  +        ?_assertEqual(error,               deep_find([a, b, a], ?STRUCT))
  +    ]}.
  +
  +deep_get_test_() ->
  +    {inparallel, [
  +        ?_assertEqual(1,         deep_get([a, a, a], ?STRUCT)),
  +        ?_assertEqual(#{a => 1}, deep_get([a, a], ?STRUCT)),
  +        ?_assertEqual(d,         deep_get([a, c], ?STRUCT, d)),
  +        ?_assertEqual(1,         deep_get([a, a, a], ?STRUCT, default)),
  +        ?_assertEqual(default,   deep_get([a, b, c], ?STRUCT, default)),
  +        ?_assertEqual(?STRUCT,   deep_get([], ?STRUCT))
  +    ] ++ error_(fun(Path, Map) -> deep_get(Path, Map) end)}.
  +
  +deep_put_test_() ->
  +    {inparallel, [
           ?_assertEqual(v,                   deep_put([], v, #{})),
           ?_assertEqual(
               v,
  
positive.code:         ?_assertEqual(Expected, deep_merge(Fun, First, Second))
      ]}.
  
  badmap_test_() ->
      {inparallel, [
          ?_assertError({badmap, 1}, deep_find([a], 1)),
          ?_assertError({badmap, 1}, deep_get([a], 1)),
          ?_assertError({badmap, 1}, deep_get([a], 1, d)),
          ?_assertError({badmap, 1}, deep_put([a], v, 1)),
          ?_assertError({badmap, 1}, deep_remove([a], 1)),
          ?_assertError({badmap, 1}, deep_merge(1, #{})),
          ?_assertError({badmap, 2}, deep_merge(#{}, 2)),
          ?_assertError({badmap, 1}, deep_merge([#{}, #{}, 1])),
          ?_assertError({badmap, 1}, deep_merge(fun(_, _) -> ok end, 1, #{})),
          ?_assertError({badmap, 2}, deep_merge(fun(_, _) -> ok end, #{}, 2))
      ]}.
  
  badpath_test_() ->
      {inparallel, [
          ?_assertError({badpath, 1}, deep_find(1, #{})),
          ?_assertError({badpath, 1}, deep_get(1, #{})),
          ?_assertError({badpath, 1}, deep_get(1, #{}, d)),
          ?_assertError({badpath, 1}, deep_put(1, v, #{})),
          ?_assertError({badpath, 1}, deep_remove(1, #{}))
      ]}.
  
  inverse_test_() ->
      {inparallel, [
          ?_assertEqual(#{1 => a, 2 => c}, inverse(#{a => 1, b => 2, c => 2}))
  
negative.code:         )
      ]}.
  
  deep_merge_test_() ->
      [First, Second|_] = Maps = [
          #{val => 1, a => 1},
          #{val => 2, b => 2, x => #{2 => true, y => #{more => stuff}}},
  