Added custom serialization for PersistentHashMap. Changed PersistentHashMap.count to .size. Added ImSetTrans so we can expose as little as possible of the TransientHashSet. Made named classes for lots of things thinking that they could be serializable, but decided against supporting that forever until someone asks for it. This should still reduce some code size through reuse. Privatized some things that should never have been public. Made singletons into enums.

Author: Glen K. Peterson

README.md

@@ -72,6 +72,10 @@ IDENTITY  is now  Const.IDENTITY
 ACCEPT    is now  ConstBool.ACCEPT
 REJECT    is now  ConstBool.REJECT
 
+org.organicdesign.fp.collections.UnmodMap.UnEntry.entryToUnEntry(Map.Entry<K,V> entry)
+is now
+org.organicdesign.fp.collections.KeyVal.of(Map.Entry<K,V> entry)
+
 Search for usages of
 map(tup(
 .toImMap(... tup(
@@ -82,12 +86,23 @@ map(kv(
 
 #### Additional changes
  - Tuple2 no longer implements Map.Entry.  Instead, a new Serializable subclass, KeyVal, was created for this purpose.
+ - Removed UnmodMap.UnEntry.entryToUnEntry(Map.Entry<K,V> entry).
  - Tuple hashcodes are now the addition of the hashcodes of each item in the tuple.
    They used to bitwise-or the first two items (and add the rest) for compatibility with Map.Entry.
-
-The function interfaces (Function0, Function1, etc.) will *not* implement Serializable.
-These interfaces are general and Serializable is too much for implementers to think about (and often irrelevant).
-However, the constants in those interfaces have been changed to implement Serializable.
+ - PersistentHashMap.ArrayNode, .BitMapIndexNode, .HashCollisionNode, and .NodeIter are now all private (were public or package).
+   There should never have been any reason to use or access these.
+ - Added ImSetTrans&lt;E&gt; interface and exposed the Transient Set implementation.
+ - Found some opportunities to use transient implementations more efficiently.
+
+#### What's *NOT* Serializable?
+ - The function interfaces (Function0, Function1, etc.) will *NOT* implement Serializable.
+    These interfaces are general and Serializable is too much for implementers to think about (and often irrelevant).
+    However, the *constants* and *singletons* in those interfaces have been changed to implement
+    Serializable.
+ - Iterators are *NOT* serializable.  They aren't in java.util.Collections either.
+   If you need an iterator to be serializable for some reason, open an issue and we'll discuss it.
+ - Transformable is not serializable.  Open an issue to discuss.
+ - Transient-HashSet, -HashMap, and -Vector are not Serializable.  Open an issue to discuss.
 
 Issues?  Questions?  Please provide feedback on the [Serialization enhancement request](https://github.com/GlenKPeterson/UncleJim/issues/10)
 

inheritanceHierarchy.odg

@@ -1,17 +1,21 @@
 package org.organicdesign.fp.collections;
 
 /**
- Allows a map to be taken from transient to persistent.  This is NOT inherently thread-safe and calls to the
- asTransient() and persistent() methods need to be wrapped in a thread-safe manner.
- This bridges that gap to let PersistentHashSet know about the asTransient() method for accessing PersistentHashMap's
- inner transient class, which in turn, allows this class to implement keySet for PersistentHashMap.  Also allows
+ You could think of this as a builder for a transient map.  It builds a little faster than the
+ persistent one.
+
+ Allows a map to be taken from transient to persistent.  This is NOT inherently thread-safe.
+ This bridges that gap to let PersistentHashSet know about the asTransient() method for accessing
+ PersistentHashMap's inner transient class, which in turn, allows this class to implement keySet
+ for PersistentHashMap.
  */
 public interface ImMapTrans<K,V> extends ImMap<K,V> {
     ImMapTrans<K,V> asTransient();
 
     /** Returns the Equator used by this map for equals comparisons and hashCodes */
     Equator<K> equator();
 
+    /** Returns a persistent/immutable version of this transient map. */
     ImMapTrans<K,V> persistent();
 
     /** {@inheritDoc} */

inheritanceHierarchy.pdf

@@ -0,0 +1,18 @@
+package org.organicdesign.fp.collections;
+
+/**
+ You could think of this as a builder for a transient set.  It builds a little faster than the
+ persistent one.  This is NOT inherently thread-safe.  The goal of this is to expose as little of
+ the TransientHashMap as possible.
+ */
+public interface ImSetTrans<E> extends ImSet<E> {
+
+    /** {@inheritDoc} */
+    @Override  ImSetTrans<E> put(E val);
+
+    /** {@inheritDoc} */
+    @Override ImSetTrans<E> without(E key);
+
+    /** Returns a persistent/immutable version of this transient map. */
+    ImSet<E> persistent();
+}