with/withoutmethods on immutable collections

[GoogleCodeExporter]

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)

Original issue reported on code.google.com by jvdne...@gmail.com on 9 Dec 2009 at 2:29

[GoogleCodeExporter]

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

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

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

Original comment by jvdne...@gmail.com on 16 Dec 2009 at 1:26

[GoogleCodeExporter]

We don't wish to attempt to turn our collections into full-blown "persistent 
data 
structures" aka "pure functional data structures". There are lots of other 
languages 
and libraries that have this if it's what you want.

Original comment by kevinb@google.com on 23 Apr 2010 at 8:31

• Changed state: WontFix

[GoogleCodeExporter]

This issue has been migrated to GitHub.

It can be found at https://github.com/google/guava/issues/<id>

Original comment by cgdecker@google.com on 1 Nov 2014 at 4:16

• Added labels: MigratedToGitHub

[GoogleCodeExporter]

Original comment by cgdecker@google.com on 3 Nov 2014 at 9:10

• Added labels: Restrict-AddIssueComment-Commit