anchor.diff:  search(_Struct, _Path, _Wrap, Default) ->
       Default().
   
  -recursive(Struct, Path, Act) ->
  -    try
  -        rec(Struct, Path, Act)
  -    catch throw:not_found ->
  -        error(bad_key)
  -    end.
  -
  -rec(Struct, [Key], Act) when is_map(Struct) ->
  +update(Struct, [Key], Act) when is_map(Struct) ->
       case maps:is_key(Key, Struct) of
           true ->
               case Act of
  
positive.code:             end;
          false ->
              case Act of
                  delete -> throw(not_found);
                  {set, Value} -> maps:put(Key, Value, Struct)
              end
      end;
  rec(Struct, [Key|Path], Act) when is_map(Struct) ->
      case maps:find(Key, Struct) of
          {ok, Value} when is_map(Value) ->
              maps:update(Key, rec(Value, Path, Act), Struct);
          error ->
              case Act of
                  delete -> throw(not_found);
                  {set, _Value} -> maps:put(Key, rec(#{}, Path, Act), Struct)
              end
      end;
  rec(_Struct, [], {set, Value}) when is_map(_Struct) ->
      Value.
  
negative.code: deep_get(Path, Struct, Default) ->
      search(Struct, Path, fun(Value) -> Value end, fun() -> Default end).
  
  deep_put(Path, Value, Struct) -> update(Struct, Path, {set, Value}).
  
  deep_remove(Path, Struct) -> update(Struct, Path, delete).
  
  deep_merge([Map|Maps]) ->
      % Key collisions prefer maps over normal values. If a map is to be written
  