Added back MutList.add() and .addAll() methods. Hopefully, this is a good idea.

Author: GlenKPeterson

CHANGE_LOG.md

@@ -5,6 +5,11 @@ 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.6.0 2021-09-21
+- Added back .add() and .addAll() methods to MutList.
+  This is sort of an experiment to see if this is more helpful than dangerous.
+  It's probably helpful, but I can't do this with all the appropriate methods/interfaces right now.
+
 ## Release 3.5.10 2021-09-21
 - Bumped dependencies
 

LICENSE.txt

@@ -108,9 +108,10 @@ The Clojure collections are licensed under the Eclipse Public License.
 Versions of them have been included in this project and modified to add type safety and implement different interfaces.
 These files are still derivative works under the EPL.
 
-Unless otherwise stated, the rest of this work is licensed under the Apache 2.0 license.
-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.
+Unless otherwise stated, the rest of this work may be licensed under EITHER the Eclipse 1.0 or the Apache 2.0.
+You get to choose!
+New contributions should be made under both licenses whenever practical.
+I believe Apache is more popular, clearer, and has been better tested in courts of law.
 
 Hermit Crab Photo by [Rushen](https://www.flickr.com/photos/rushen/12171498934/in/photostream/)
 

README.md

@@ -38,31 +38,31 @@ http://mvnrepository.com/artifact/org.organicdesign/Paguro
 	-->
 	<groupId>org.organicdesign</groupId>
 	<artifactId>Paguro</artifactId>
-	<version>3.5.10</version>
+	<version>3.6.0</version>
 	<packaging>jar</packaging>
 
 	<name>Paguro</name>
 	<description>Immutable Clojure collections and a Transformation abstraction for Java 8+, immutably, type-safely, and with good performance.</description>
 	<url>https://github.com/GlenKPeterson/Paguro</url>
 
 	<licenses>
-		<license>
-			<name>The Apache License, Version 2.0</name>
-			<url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
-			<comments>The license for most of the files in this project.</comments>
-		</license>
 		<license>
 			<name>Eclipse Public License - v 1.0</name>
 			<url>https://www.eclipse.org/legal/epl-v10.html</url>
 			<comments>For the persistent collections in the
 				collections/ folder. These files are derivative
 				works based on the Clojure source code.</comments>
 		</license>
+		<license>
+			<name>The Apache License, Version 2.0</name>
+			<url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
+			<comments>This is an optional license (user can choose it) for the files in this project that were never part of Clojure.</comments>
+		</license>
 	</licenses>
 	<developers>
 		<developer>
 			<name>Glen K. Peterson</name>
-			<email>glen@organicdesign.org</email>
+			<email>glen[email protected]</email>
 			<organization>PlanBase Inc.</organization>
 		</developer>
 	</developers>

pom.xml

@@ -15,6 +15,8 @@
 
 import org.jetbrains.annotations.NotNull;
 
+import java.util.Collection;
+
 /**
  A mutate-in-place interface using the same copy-on-write methods as {@link BaseList} and
  {@link ImList} so that you can treat mutable and immutable lists the same.
@@ -28,16 +30,30 @@ public interface MutList<E> extends BaseList<E> {
     MutList<E> append(E val);
 
     // TODO: Is this a good idea?  Kotlin does this...
-//    /**
-//     Ensures that this collection contains the specified element (optional operation).
-//     Returns true if this collection changed as a result of the call.
-//     */
-//    @SuppressWarnings("deprecation")
-//    @Override default boolean add(E val) {
-//        int origSize = size();
-//        append(val);
-//        return origSize != size();
-//    }
+    // I'm concerned that we cannot provide good implementations for all these methods.
+    // Will implementing some be a benefit?
+    // Or just a temptation to use other deprecated methods?
+    // I'm going to try this with a few easy methods to see how it goes.
+    // These are all technically "optional" operations anyway.
+    /**
+     Ensures that this collection contains the specified element (optional operation).
+     Returns true if this collection changed as a result of the call.
+     */
+    @SuppressWarnings("deprecation")
+    @Override default boolean add(E val) {
+        append(val);
+        return true;
+    }
+
+    /**
+     * Appends all the elements in the specified collection to the end of this list,
+     * in the order that they are returned by the specified collection's iterator.
+     */
+    @SuppressWarnings("deprecation")
+    @Override default boolean addAll(@NotNull Collection<? extends E> c) {
+        concat(c);
+        return true;
+    }
 
     /** Returns a immutable version of this mutable list. */
     ImList<E> immutable();

src/main/java/org/organicdesign/fp/collections/MutList.java

@@ -56,4 +56,25 @@ static class TestList<E> implements MutList<E> {
         assertEquals(control.size(), test.size());
         assertEquals(control, test);
     }
+
+    @Test public void testOriginalMethods() {
+        List<String> control = new ArrayList<>();
+        MutList<String> test = new TestList<>(new ArrayList<>());
+
+        for (int i = 0; i < 32; i++) {
+            String ord = ordinal(i);
+            assertTrue(control.add(ord));
+            assertTrue(test.add(ord));
+            assertEquals(control.size(), test.size());
+            assertEquals(control, test);
+        }
+
+        List<String> moreStuff = Arrays.asList("this", "is", "more", "stuff");
+        assertTrue(control.addAll(moreStuff));
+        assertTrue(test.addAll(moreStuff));
+
+        assertEquals(control.size(), test.size());
+        assertEquals(control, test);
+    }
+
 }