Use standard abstract collections.

Author: ilya-g

kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/AbstractImmutableMap.kt

@@ -1,7 +1,7 @@
 package kotlinx.collections.immutable
 
 import org.pcollections.PMap
-import java.util.*
+import java.util.ConcurrentModificationException
 
 internal abstract class AbstractImmutableMap<K, out V> protected constructor(protected val impl: PMap<K, @UnsafeVariance V>) : ImmutableMap<K, V> {
 
@@ -47,7 +47,7 @@ internal abstract class AbstractImmutableMap<K, out V> protected constructor(pro
     protected abstract fun wrap(impl: PMap<K, @UnsafeVariance V>): AbstractImmutableMap<K, V>
 
 
-    abstract class Builder<K, V> protected constructor(protected var value: AbstractImmutableMap<K, V>, protected var impl: PMap<K, V>) : ImmutableMap.Builder<K, V>, AbstractMap<K, V>() {
+    abstract class Builder<K, V> protected constructor(protected var value: AbstractImmutableMap<K, V>, protected var impl: PMap<K, V>) : ImmutableMap.Builder<K, V>, AbstractMutableMap<K, V>() {
         override fun build(): ImmutableMap<K, V> = value.wrap(impl).apply { value = this }
 
         override val size: Int get() = impl.size
@@ -63,7 +63,9 @@ internal abstract class AbstractImmutableMap<K, out V> protected constructor(pro
 
         private var entrySet: MutableSet<MutableMap.MutableEntry<K, V>>? = null
         override val entries: MutableSet<MutableMap.MutableEntry<K, V>>
-            get() = entrySet ?: object : MutableSet<MutableMap.MutableEntry<K, V>>, AbstractSet<MutableMap.MutableEntry<K, V>>() {
+            get() = entrySet ?: object : AbstractMutableSet<MutableMap.MutableEntry<K, V>>() {
+                override fun add(element: MutableMap.MutableEntry<K, V>): Boolean = throw UnsupportedOperationException()
+
                 override val size: Int get() = impl.size
                 override fun isEmpty(): Boolean = impl.isEmpty()
                 override fun clear() = this@Builder.clear()
@@ -118,11 +120,6 @@ internal abstract class AbstractImmutableMap<K, out V> protected constructor(pro
 //        override val keys: MutableSet<K>
 //        override val values: MutableCollection<V>
 
-        override val values: MutableCollection<V>
-            get() = super.values
-        override val keys: MutableSet<K>
-            get() = super.keys
-
         override abstract fun clear()
 
         override fun put(key: K, value: V): V?
@@ -152,7 +149,7 @@ internal fun <K, V> PMap<K, V>.contains(key: K, value: @UnsafeVariance V): Boole
     = this[key]?.let { candidate -> candidate == value } ?: (value == null && containsKey(key))
 
 
-
+/*
 private open class ImmutableCollectionWrapper<E>(protected val impl: Collection<E>) : ImmutableCollection<E> {
     override val size: Int get() = impl.size
     override fun isEmpty(): Boolean = impl.isEmpty()
@@ -185,3 +182,4 @@ private class ImmutableSetWrapper<E>(impl: Set<E>) : ImmutableSet<E>, ImmutableC
     override fun removeAll(predicate: (E) -> Boolean): ImmutableSet<E> = super.removeAll(predicate) as ImmutableSet
     override fun clear(): ImmutableSet<E> = immutableSetOf()
 }
+*/

kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/AbstractImmutableSet.kt

@@ -1,7 +1,7 @@
 package kotlinx.collections.immutable
 
 import org.pcollections.PSet
-import java.util.*
+import java.util.ConcurrentModificationException
 
 internal abstract class AbstractImmutableSet<out E> protected constructor(protected val impl: PSet<@UnsafeVariance E>) : ImmutableSet<E> {
 
@@ -31,7 +31,7 @@ internal abstract class AbstractImmutableSet<out E> protected constructor(protec
 
     protected abstract fun wrap(impl: PSet<@UnsafeVariance E>): AbstractImmutableSet<E>
 
-    abstract class Builder<E> internal constructor(protected var value: AbstractImmutableSet<E>, protected var impl: PSet<E>) : AbstractSet<E>(), ImmutableSet.Builder<E> {
+    abstract class Builder<E> internal constructor(protected var value: AbstractImmutableSet<E>, protected var impl: PSet<E>) : AbstractMutableSet<E>(), ImmutableSet.Builder<E> {
         override fun build(): AbstractImmutableSet<E> = value.wrap(impl).apply { value = this }
         // delegating to impl
         override val size: Int get() = impl.size

kotlinx-collections-immutable/src/main/kotlin/kotlinx/collections/immutable/ImmutableVectorList.kt

@@ -1,7 +1,6 @@
 package kotlinx.collections.immutable
 
 import org.pcollections.*
-import java.util.*
 
 internal class ImmutableVectorList<out E> private constructor(private val impl: PVector<E>) : ImmutableList<E> {
 
@@ -59,26 +58,21 @@ internal class ImmutableVectorList<out E> private constructor(private val impl:
         public fun <T> emptyOf(): ImmutableVectorList<T> = EMPTY
     }
 
-    class Builder<E> internal constructor(private var value: ImmutableVectorList<E>, private var impl: PVector<E>) : AbstractList<E>(), ImmutableList.Builder<E> {
+    class Builder<E> internal constructor(private var value: ImmutableVectorList<E>, private var impl: PVector<E>) : AbstractMutableList<E>(), ImmutableList.Builder<E> {
         override fun build(): ImmutableVectorList<E> = value.wrap(impl).apply { value = this }
         // delegating to impl
         override val size: Int get() = impl.size
+        override fun get(index: Int): E = impl.get(index)
+
         override fun contains(element: @UnsafeVariance E): Boolean = impl.contains(element)
         override fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean = impl.containsAll(elements)
-        override fun get(index: Int): E = impl.get(index)
         override fun indexOf(element: @UnsafeVariance E): Int = impl.indexOf(element)
-        override fun isEmpty(): Boolean = impl.isEmpty()
-
-//        override fun iterator(): MutableIterator<E> = listIterator(0)
         override fun lastIndexOf(element: @UnsafeVariance E): Int = impl.lastIndexOf(element)
-//        override fun listIterator(): MutableListIterator<E> = listIterator(0)
-//        override fun listIterator(index: Int): MutableListIterator<E> = impl.listIterator(0)
+
         override fun equals(other: Any?): Boolean = impl.equals(other)
         override fun hashCode(): Int = impl.hashCode()
         override fun toString(): String = impl.toString()
 
-
-
         private inline fun mutate(operation: (PVector<E>) -> PVector<E>): Boolean {
             val newValue = operation(impl)
             if (newValue !== impl) {

kotlinx-collections-immutable/tests/src/main/kotlin/ImmutableArrayList.kt

@@ -1,11 +1,9 @@
 package kotlinx.collections.immutable
 
 import java.util.*
+import kotlin.collections.AbstractList
 
-public class ImmutableArrayList<out E> private constructor(private val impl: Array<E>): ImmutableList<E> {
-
-    private var _implAsList: List<E>? = null
-    private val implAsList: List<E> get() = _implAsList ?: impl.asList().apply { _implAsList = this }
+public class ImmutableArrayList<out E> private constructor(private val impl: Array<E>): ImmutableList<E>, AbstractList<E>() {
 
     override val size: Int get() = impl.size
     override fun isEmpty(): Boolean = impl.isEmpty()
@@ -17,9 +15,6 @@ public class ImmutableArrayList<out E> private constructor(private val impl: Arr
 
 
     override fun iterator(): Iterator<E> = impl.iterator()
-    override fun listIterator(): ListIterator<E> = implAsList.listIterator()
-
-    override fun listIterator(index: Int): ListIterator<E> = implAsList.listIterator(index)
 
     override fun subList(fromIndex: Int, toIndex: Int): ImmutableList<E> = ImmutableArrayList(impl.copyOfRange(fromIndex, toIndex))
 
@@ -28,8 +23,8 @@ public class ImmutableArrayList<out E> private constructor(private val impl: Arr
     override fun addAll(elements: Collection<@UnsafeVariance E>): ImmutableList<E> = ImmutableArrayList(impl + elements)
 
     override fun remove(element: @UnsafeVariance  E): ImmutableList<E> {
-        val values = implAsList - element
-        return if (values.size < impl.size) ImmutableArrayList(values.toTypedArray<Any?>() as Array<E>) else this
+        val index = indexOf(element).takeUnless { it < 0 } ?: return this
+        return removeAt(index)
     }
 
     override fun removeAll(elements: Collection<@UnsafeVariance E>): ImmutableList<E> {
@@ -52,15 +47,10 @@ public class ImmutableArrayList<out E> private constructor(private val impl: Arr
 
     override fun removeAt(index: Int): ImmutableList<E> = mutate { it.removeAt(index) }
 
-    override fun builder(): ImmutableList.Builder<@UnsafeVariance E> = object : ArrayList<E>(implAsList), ImmutableList.Builder<E> {
+    override fun builder(): ImmutableList.Builder<@UnsafeVariance E> = object : ArrayList<E>(impl.asList()), ImmutableList.Builder<E> {
         override fun build(): ImmutableList<E> = if (this.modCount == 0) this@ImmutableArrayList else ImmutableArrayList(this.toArray() as Array<E>)
     }
 
-
-    override fun equals(other: Any?): Boolean = (other as? List<*>)?.equals(implAsList) ?: false
-    override fun hashCode(): Int = Arrays.hashCode(impl)
-    override fun toString(): String = Arrays.toString(impl)
-
     companion object {
         public val EMPTY: ImmutableArrayList<Nothing> = ImmutableArrayList(emptyArray<Any?>()) as ImmutableArrayList<Nothing>
     }