Something along the lines of:

final ImmutableMap<Integer,String> map = ImmutableMap.of(1, "a", 2, "b");

ImmutableMap<Integer,String> result; result = map.with(3, "c"); // { 1 : "a", 2 : "b", 3 : "c" } result = map.with(3, "foo"); // { 1 : "a", 2 : "b", 3 : "foo" } result = map.without(3); // { 1 : "a", 2 : "b" }

and possibly bulk overloads

I understand the performance implications of using these, but they would still be very useful. Currently I use:

public static <K,V> ImmutableMap<K,V> with( final ImmutableMap<K,V> map, final K key, final V value) { return ImmutableMap.<K,V>builder() .putAll(Maps.filterKeys(map, Predicates.not(Preds.is(key)))).put(key, value).build(); }

(Preds.is is what used to be Predicates.isSameAs)

But I would think that this can be done better if it were implemented in the collection.

In the long run, immutable collections would need a different implementation to be able to use these methods in moderately performance sensitive areas. (the way clojure's persistent data structures are implemented comes to mind, and I would think scala has something similar, though I am not sure)

public static ImmutableMap with(final ImmutableMap map, final K key, final V value) { final Map filtered = Maps.filterKeys(map, Predicates.not(Preds.is(key))); return ImmutableMap.builder() .putAll(filtered) .put(key, value) .build(); }

public static ImmutableMap without(final ImmutableMap map, final K key) { final Map filtered = Maps.filterKeys(map, Predicates.not(Predicates.in(Collections.singleton(key)))); return ImmutableMap.copyOf(filtered); }

public static ImmutableMap without(final ImmutableMap map, final Set keys) { final Map filtered = Maps.filterKeys(map, Predicates.not(Predicates.in(keys))); return ImmutableMap.copyOf(filtered); }

This issue has been moved to the Guava project (keeping the same id number). Simply replace 'google-collections' with 'guava-libraries' in your address bar and it should take you there.