anchor.diff:          a => 3,
           b => 4
       },
  -    c => ?LIST,
       d => []
   }).
   
  
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:         ?_assertError({badvalue, [d]},   Function([d, x], ?STRUCT))
      ]}.
  
  deep_remove_test_() ->
      {inparallel, [
          ?_assertEqual(?STRUCT, deep_remove([], ?STRUCT)),
          ?_assertEqual(?STRUCT, deep_remove([y], ?STRUCT)),
  