Merged changes from master branch:

 - Made most Cowry methods public
 would throw an exception at Runtime.  I had done something that in retrospect is obviously dumb.
 - Documented Cowry (Copy-On Write aRraY) better.
  These are type-safe utility methods for dealing with arrays.
 This project still aims to keep you from needing to deal with arrays, but sometimes you do, and it's handy to have copy-on-write routines for doing it.
 More of these methods could be made public if they are needed.
 - [Nate Austin](https://github.com/navision)'s memory-efficient iteration of just keys or just values from maps.  Thank you Nate!
 - Fixed split() to handle splitIndex = 0 and splitIndex = size() thanks to a bug report from [Jonathan Cornaz](https://github.com/jcornaz) (curator of [collekt](https://github.com/jcornaz/collekt))
 - Added Transformable.toImRrbt() and .toMutableRrbt() to make it convenient to transform things into RRB-Trees.
 - Fixed bugs found using FindBugs - thanks to @cprice404.  There are still some reported bugs, but
 I think they are rare corner cases that lack clear solutions.  This was the low-hanging fruit.
    - Option.NONE is removed to avoid possible circular instantiation.  Use None.NONE instead.
    - Moved Indented to new indent package.
    - Moved static methods from the Indented interface to a new IndentedUtils class.
    - STRINGS array constant from Indented interface is now private to the IndentedUtils class.
    - UnmodMap.UnEntry.EntryToUnEntryIter.next() now returns a Tuple2 instead of some other one-off class.

Author: Glen K. Peterson

CHANGE_LOG.md

@@ -5,6 +5,25 @@ releases on the way from an old version to a new one.  Fix any deprecation warni
 release before upgrading to the next one.  The documentation next to each Deprecated annotation
 tells you what to use instead.  Once we delete the deprecated methods, that documentation goes too.
 
+## Release 3.5.2: Fixes from Master
+ - Made most Cowry methods public
+ - Fixed a bug (reported by [fcurts](https://github.com/fcurts) - with unit test!) where Heterogeneous RrbTrees of more than 32 items
+ would throw an exception at Runtime.  I had done something that in retrospect is obviously dumb.
+ - Documented Cowry (Copy-On Write aRraY) better.
+  These are type-safe utility methods for dealing with arrays.
+ This project still aims to keep you from needing to deal with arrays, but sometimes you do, and it's handy to have copy-on-write routines for doing it.
+ More of these methods could be made public if they are needed.
+ - [Nate Austin](https://github.com/navision)'s memory-efficient iteration of just keys or just values from maps.  Thank you Nate!
+ - Fixed split() to handle splitIndex = 0 and splitIndex = size() thanks to a bug report from [Jonathan Cornaz](https://github.com/jcornaz) (curator of [collekt](https://github.com/jcornaz/collekt))
+ - Added Transformable.toImRrbt() and .toMutableRrbt() to make it convenient to transform things into RRB-Trees.
+ - Fixed bugs found using FindBugs - thanks to @cprice404.  There are still some reported bugs, but
+ I think they are rare corner cases that lack clear solutions.  This was the low-hanging fruit.
+    - Option.NONE is removed to avoid possible circular instantiation.  Use None.NONE instead.
+    - Moved Indented to new indent package.
+    - Moved static methods from the Indented interface to a new IndentedUtils class.
+    - STRINGS array constant from Indented interface is now private to the IndentedUtils class.
+    - UnmodMap.UnEntry.EntryToUnEntryIter.next() now returns a Tuple2 instead of some other one-off class. 
+
 ### Release 3.5.1: Kotlin compatibility
  - Renamed artifact to Paguro-KF for "Kotlin-Friendly"
  - This was originally 3.1.1, but the master branch ended up using that number, so now this branch is 3.5.x

Paguro.iml

@@ -37,8 +37,10 @@
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" scope="TEST" name="Maven: org.organicdesign.testUtils:TestUtils:0.0.6" level="project" />
     <orderEntry type="library" scope="TEST" name="Maven: junit:junit:4.12" level="project" />
     <orderEntry type="library" scope="TEST" name="Maven: org.hamcrest:hamcrest-core:1.3" level="project" />
-    <orderEntry type="library" scope="TEST" name="Maven: org.organicdesign.testUtils:TestUtils:0.0.6" level="project" />
+    <orderEntry type="library" scope="TEST" name="Maven: org.organicdesign.testUtils:TestUtils:0.0.7" level="project" />
+    <orderEntry type="library" scope="TEST" name="Maven: org.jetbrains:annotations:15.0" level="project" />
   </component>
 </module>

README.md

@@ -10,44 +10,42 @@ Photo by [Rushen](https://www.flickr.com/photos/rushen/12171498934/in/photostrea
 # Overview
 Paguro is short for the Latin "Paguroidea" - the name of the Hermit Crab superfamily in Biology.
 These collections grow by adding a new shell, leaving the insides the same, much the way [Hermit Crabs trade up to a new shell when they grow](https://www.youtube.com/watch?v=f1dnocPQXDQ).
-This project used to be called UncleJim.
 
-# News
-### RRB Tree Released!
-An [RRB Tree](https://glenkpeterson.github.io/Paguro/apidocs/index.html?org/organicdesign/fp/collections/RrbTree.html) is an immutable List (like Clojure's PersistentVector) that also supports random inserts, deletes, and can be split and joined back together in logarithmic time.
-There's been one for Scala for a while (Bagwell/Rompf who wrote the paper were Scala people), and a native Clojure one, but neither is super helpful for Java programmers.
-This is an entirely new Apache 2.0 Java implementation.
+[![Join the chat at https://gitter.im/GlenKPeterson/Paguro](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/GlenKPeterson/Paguro?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-It's easy to use:
-```java
-import org.organicdesign.fp.collections.RrbTree.ImRrbt;
-import static org.organicdesign.fp.StaticImports.rrb;
-
-class Foo {
-    public static void main(String[] args) {
-        ImRrbt<String> rrb = rrb("This", "is", "a", "list");
-        rrb = rrb.insert(0, "Hello!");
-        System.out.println("rrb: " + rrb);
-    }
-}
+# Maven Artifact
+
+Available from the [Maven Repository](http://mvnrepository.com/artifact/org.organicdesign/Paguro) as:
+```xml
+<!--
+If you're using Kotlin and Java, you want the 3.5 version in the KotlinFootWetting branch.
+Java-only users want 3.x from the main branch.
+ -->
+<dependency>
+        <groupId>org.organicdesign</groupId>
+        <artifactId>Paguro</artifactId>
+        <version>3.5.2</version>
+</dependency>
 ```
 
-### How to update
-An upgrade script is in the [Change Log](CHANGE_LOG.md#30-upgrade) along with a description of the 3.0 changes (there were may!).
+The Maven artifact is the easiest way to use Paguro, but you can [build from source](#build-from-source) if you want to.
+
+# News
+### RRB Tree Released!
 
-### Other new features
-[Union types](https://glenkpeterson.github.io/Paguro/apidocs/index.html?org/organicdesign/fp/oneOf/package-summary.html) for Java!  Well, an approximation of them anyway.
+An [RRB Tree](https://glenkpeterson.github.io/Paguro/apidocs/index.html?org/organicdesign/fp/collections/RrbTree.html) is an immutable List (like Clojure's PersistentVector) that also supports random inserts, deletes, and can be split and joined back together in logarithmic time.  Details: https://github.com/GlenKPeterson/Paguro/releases/tag/3.0.16
 
 ### Next Major Release will be Paguro 4.0, "Kotlin Compatibility"
 
-Some things will have to be renamed in order to fit better with the Kotlin standard library.
-Notably MutableList, MutableMap, and MutableSet conflict with the same-named classes in Kotlin.
+This announcement is making some people nervous even as it makes others happy.  The primary curator (Glen) will still continue using Paguro in both Java and Kotlin for at least a year, maybe forever.  Kotlin is nearly 100% backward-compatible with Java 8.  I've met several people who know Paguro but not Kotlin, but I have yet to meet the person who knows both and likes Paguro but not Kotlin.
 
-The primary programmer on this project is now writing more Kotlin than Java.
-If you like Paguro, you'll probably prefer Kotlin too.
-Kotlin seems nearly 100% compatible with Java, meaning when you call Kotlin from Java, you could think you're calling native Java.
-So even if this becomes an all Kotlin project, Java programmers should have no trouble using it.
-If Java-only programmers object for some reason, we can make a Java-only branch.
+You are probably interested in Paguro because you like Immutability, Functional Programming (maybe as pure as Haskell, maybe not), and Types.  Kotlin is a briefer Java that assumes immutability, makes Functional Programming easier, and plugs 3/4 of the quirks in Java's generic type system.  If you're concerned about the future of Paguro, I think the best way to put your worries to rest is to try Kotlin.  It's pretty great!
+
+If a rewrite in Kotlin sounds good to you, consider voting for [this issue](https://youtrack.jetbrains.com/issue/KT-4779) because without it, I'll have to maintain separate Java and Kotlin code.
+
+Check back for more details as the 4.x release progresses.
+
+Check the [Change Log](CHANGE_LOG.md) for details of recent changes.
 
 # Features
 
@@ -60,31 +58,14 @@ If Java-only programmers object for some reason, we can make a Java-only branch.
   * `map(tup(1, "single"), tup(2, "double"), tup(3, "triple"))` - an immutable map that uses integers to look up appropriate strings.
 * **Extensible, immutable tuples** [api](https://glenkpeterson.github.io/Paguro/apidocs/index.html?org/organicdesign/fp/tuple/package-summary.html)/[src](src/main/java/org/organicdesign/fp/tuple) - use them for rapid prototyping, then later extend them to make your own lightweight, immutable Java classes with correct `equals()`, `hashCode()`, and `toString()` implementations.
 * **Lazy initialization** [api](https://glenkpeterson.github.io/Paguro/apidocs/index.html?org/organicdesign/fp/function/LazyRef.html)/[src](src/main/java/org/organicdesign/fp/function/LazyRef.java) - LazyRef thread-safely performs initialization and frees initialization resources on first use.  Subsequent uses get the now-constant initialized value.  Use this instead of static initializers to avoid initialization loops.  Cache results of expensive operations for reuse.
+* **Union types** [api](https://glenkpeterson.github.io/Paguro/apidocs/index.html?org/organicdesign/fp/oneOf/package-summary.html)/[src](src/main/java/org/organicdesign/fp/oneOf) - Not as nice as being built into the language, but they extend type safety outside the object hierarchy.
 * **Memoization** [api](https://glenkpeterson.github.io/Paguro/apidocs/org/organicdesign/fp/function/Fn3.html#memoize-org.organicdesign.fp.function.Fn3-)/[src](src/main/java/org/organicdesign/fp/function/Fn3.java#L42) - Turns function calls into hashtable lookups to speed up slow functions over a limited range of inputs.
 * **Tiny** with no dependencies - The entire project fits in a 270K jar file that is compiled in the compact1 profile.
 
 [API Docs](https://glenkpeterson.github.io/Paguro/apidocs/index.html)
 
 Paguro takes advantage of Java's type inferencing.  It eschews void return types, arrays, primatives, and checked exceptions in lambdas.  It can decrease the amount of code you need to write by a factor of at 2x-3x.  Using functional transfomrations instead of loops focuses you on choosing the right collections which leads to more readable code AND better Big O complexity/scalability.
 
-[![Build Status](https://travis-ci.org/GlenKPeterson/Paguro.svg?branch=master)](https://travis-ci.org/GlenKPeterson/Paguro)
-[![Code Coverage](http://codecov.io/github/GlenKPeterson/Paguro/coverage.svg?branch=master)](http://codecov.io/github/GlenKPeterson/Paguro?branch=master)
-
-[![Join the chat at https://gitter.im/GlenKPeterson/Paguro](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/GlenKPeterson/Paguro?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-Available from the [Maven Repository](http://mvnrepository.com/artifact/org.organicdesign/Paguro) as:
-```xml
-<!--
-If you're new to Paguro, consider starting with the streamlined
-3.0 Alpha version instead (on the 2016-05-22_RRB-Tree branch)
- -->
-<dependency>
-        <groupId>org.organicdesign</groupId>
-        <artifactId>Paguro-KF</artifactId>
-        <version>3.5.1</version>
-</dependency>
-```
-
 # Details
 
 ```java
@@ -152,7 +133,7 @@ It started with a Software Engineering Stack Exchange question: [Why doesn't Jav
 
 ### Q: Why Java instead of another/better JVM language?
 
-[Why Java?](https://github.com/GlenKPeterson/Paguro/wiki/Why-is-UncleJim-written-in-Java%3F)
+[Why Java?](https://github.com/GlenKPeterson/Paguro/wiki/Why-is-Paguro-written-in-Java%3F)
 That said, this could become a Kotlin-based project.
 
 # Future Development Ideas (as of 2017-09-10)
@@ -180,5 +161,54 @@ Unless otherwise stated, the rest of this work is licensed under the Apache 2.0
 New contributions should be made under the Apache 2.0 license whenever practical.
 I believe it is more popular, clearer, and has been better tested in courts of law.
 
+# Build from Source
+
+The [pre-built maven artifact](#maven-artifact) is the easiest way to use Paguro.
+Mose users do not need to build Paguro from source.
+
+#### Prerequisites
+Paguro should build on Ubuntu 16.04 and later with `openjdk-8-jdk`, `git`, and `maven` installed from the official repositories.  A compiler bug in javac 1.8.0_31 prevents building Paguro, but OpenJDK 1.8.0.91 and later (or Oracle) should work on Windows or Mac.
+
+##### Environment Variables
+Depending on how you installed Java and Maven, you may need to set some of the following in your `~/.profile` file and reboot (or source that file like `. ~/.profile` from the command line you will use for the build).  Or do whatever Windows does.  If your tools are installed in different directories, you will have to fix the following:
+```bash
+export JDK_HOME=/usr/lib/jvm/java-8-openjdk-amd64
+export JAVA_HOME=$JDK_HOME/jre
+export M2_HOME=$TOOLS/apache-maven-3.3.9/
+export M2="$M2_HOME"bin
+export PATH=$PATH:$M2
+```
+
+##### Build
+```bash
+# Start in an appropriate directory
+
+# You need TestUtils for Paguro's equality testing.
+# The first time you build, get a local copy of that and Paguro
+git clone https://github.com/GlenKPeterson/TestUtils.git
+git clone https://github.com/GlenKPeterson/Paguro.git
+
+# Build TestUtils:
+cd TestUtils
+git pull
+mvn clean install
+cd ..
+
+# Build Paguro:
+cd Paguro
+git pull
+mvn clean install
+cd ..
+```
+
+# Contributing
+
+If you submit a patch, please:
+ - Keep the changes minimal (don't let your IDE reformat whole files).
+ - Try to match the code style as best you can.
+ - Clearly document your changes.
+ - Update the unit tests to clearly and simply prove that your code works.
+ - It's a good idea to discuss proposed changes by opening an issue on github before you spend time coding.
+
 # More
 Additional information is in: [README2.md](README2.md).

README2.md

@@ -34,13 +34,6 @@ Joshua Bloch for his book, Effective Java.
 
 Rich Hickey for Clojure
 
-# Build from Source
-
-- Java 8
-- Maven
-- First `mvn clean install` on: https://github.com/GlenKPeterson/TestUtils
-- Then `mvn clean test` on Paguro
-
 # Think about:
  - Xform.MapDesc is not serializable.  Really none of xform is serializable.
  - Think about adding StaticImports.xform(String)