Merge branch 'develop': new persistent collection implementations and interfaces

Author: ilya-g

kotlinx-collections-immutable/build.gradle

@@ -1,5 +1,5 @@
 buildscript {
-    ext.kotlin_version = "1.1.0"
+    ext.kotlin_version = "1.3.11"
 
     repositories {
         jcenter()
@@ -44,6 +44,7 @@ dependencies {
 project('tests') {
     dependencies {
         compile project(path: ':kotlinx-collections-immutable', configuration: 'shadow')
+        testCompile 'com.google.guava:guava-testlib:18.0'
     }
 }
 

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

@@ -16,10 +16,12 @@
 
 package kotlinx.collections.immutable
 
+import kotlinx.collections.immutable.adapters.ImmutableCollectionAdapter
+import kotlinx.collections.immutable.adapters.ImmutableSetAdapter
 import org.pcollections.PMap
 import java.util.ConcurrentModificationException
 
-internal abstract class AbstractImmutableMap<K, out V> protected constructor(protected val impl: PMap<K, @UnsafeVariance V>) : ImmutableMap<K, V> {
+internal abstract class AbstractImmutableMap<K, out V> protected constructor(protected val impl: PMap<K, @UnsafeVariance V>) : PersistentMap<K, V> {
 
     abstract class AbstractImmutableEntry<out K, out V> : Map.Entry<K, V> {
         override fun equals(other: Any?): Boolean = other is Map.Entry<*,*> && other.key == key && other.value == value
@@ -40,31 +42,31 @@ internal abstract class AbstractImmutableMap<K, out V> protected constructor(pro
 
 
     // should it be immutable set/collection or just read-only?
-    private var _keys: Set<K>? = null
-    final override val keys: Set<K> get() = _keys ?: createKeys().apply { _keys = this }
-    protected open fun createKeys(): Set<K> = impl.keys
-
-    private var _values: Collection<V>? = null
-    final override val values: Collection<V> get() = _values ?: createValues().apply { _values = this }
-    protected open fun createValues(): Collection<V> = impl.values
-
-    private var _entries: Set<Map.Entry<K, V>>? = null
-    final override val entries: Set<Map.Entry<K, V>> get() = _entries ?: createEntries().apply { _entries = this }
-    protected open fun createEntries(): Set<Map.Entry<K, V>> = impl.entries
-
-    override fun put(key: K, value: @UnsafeVariance V): ImmutableMap<K, V> = wrap(impl.plus(key, value))
-    override fun putAll(m: Map<out K, @UnsafeVariance V>): ImmutableMap<K, V> = wrap(impl.plusAll(m))
-    override fun remove(key: K): ImmutableMap<K, V> = wrap(impl.minus(key))
-    override fun remove(key: K, value: @UnsafeVariance V): ImmutableMap<K, V>
+    private var _keys: ImmutableSet<K>? = null
+    final override val keys: ImmutableSet<K> get() = _keys ?: createKeys().apply { _keys = this }
+    protected open fun createKeys(): ImmutableSet<K> = ImmutableSetAdapter(impl.keys)
+
+    private var _values: ImmutableCollection<V>? = null
+    final override val values: ImmutableCollection<V> get() = _values ?: createValues().apply { _values = this }
+    protected open fun createValues(): ImmutableCollection<V> = ImmutableCollectionAdapter(impl.values)
+
+    private var _entries: ImmutableSet<Map.Entry<K, V>>? = null
+    final override val entries: ImmutableSet<Map.Entry<K, V>> get() = _entries ?: createEntries().apply { _entries = this }
+    protected open fun createEntries(): ImmutableSet<Map.Entry<K, V>> = ImmutableSetAdapter(impl.entries)
+
+    override fun put(key: K, value: @UnsafeVariance V): PersistentMap<K, V> = wrap(impl.plus(key, value))
+    override fun putAll(m: Map<out K, @UnsafeVariance V>): PersistentMap<K, V> = wrap(impl.plusAll(m))
+    override fun remove(key: K): PersistentMap<K, V> = wrap(impl.minus(key))
+    override fun remove(key: K, value: @UnsafeVariance V): PersistentMap<K, V>
             = if (!impl.contains(key, value)) this else wrap(impl.minus(key))
 
     override abstract fun builder(): Builder<K, @UnsafeVariance V>
 
     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>, AbstractMutableMap<K, V>() {
-        override fun build(): ImmutableMap<K, V> = value.wrap(impl).apply { value = this }
+    abstract class Builder<K, V> protected constructor(protected var value: AbstractImmutableMap<K, V>, protected var impl: PMap<K, V>) : PersistentMap.Builder<K, V>, AbstractMutableMap<K, V>() {
+        override fun build(): AbstractImmutableMap<K, V> = value.wrap(impl).apply { value = this }
 
         override val size: Int get() = impl.size
         override fun isEmpty(): Boolean = impl.isEmpty()
@@ -164,38 +166,3 @@ internal abstract class AbstractImmutableMap<K, out V> protected constructor(pro
 internal fun <K, V> PMap<K, V>.contains(key: K, value: @UnsafeVariance V): Boolean
     = 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()
-    override fun contains(element: @UnsafeVariance E): Boolean = impl.contains(element)
-    override fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean = impl.containsAll(elements)
-    override fun iterator(): Iterator<E> = impl.iterator()
-
-    override fun equals(other: Any?): Boolean = impl.equals(other)
-    override fun hashCode(): Int = impl.hashCode()
-    override fun toString(): String = impl.toString()
-
-    override fun builder(): ImmutableCollection.Builder<E> = ImmutableVectorList.emptyOf<E>().builder().apply { addAll(impl) }
-
-    override fun add(element: E): ImmutableCollection<E> = builder().apply { add(element) }.build()
-    override fun addAll(elements: Collection<E>): ImmutableCollection<E> = builder().apply { addAll(elements) }.build()
-    override fun remove(element: E): ImmutableCollection<E> = builder().apply { remove(element) }.build()
-    override fun removeAll(elements: Collection<E>): ImmutableCollection<E> = builder().apply { removeAll(elements) }.build()
-    override fun removeAll(predicate: (E) -> Boolean): ImmutableCollection<E> = builder().apply { removeAll(predicate) }.build()
-    override fun clear(): ImmutableCollection<E> = immutableListOf()
-}
-
-private class ImmutableSetWrapper<E>(impl: Set<E>) : ImmutableSet<E>, ImmutableCollectionWrapper<E>(impl) {
-
-    override fun builder(): ImmutableSet.Builder<E> = ImmutableOrderedSet.emptyOf<E>().builder().apply { addAll(impl) }
-
-    override fun add(element: E): ImmutableSet<E> = super.add(element) as ImmutableSet
-    override fun addAll(elements: Collection<E>): ImmutableSet<E> = super.addAll(elements) as ImmutableSet
-    override fun remove(element: E): ImmutableSet<E> = super.remove(element) as ImmutableSet
-    override fun removeAll(elements: Collection<E>): ImmutableSet<E> = super.removeAll(elements) as ImmutableSet
-    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

@@ -19,7 +19,7 @@ package kotlinx.collections.immutable
 import org.pcollections.PSet
 import java.util.ConcurrentModificationException
 
-internal abstract class AbstractImmutableSet<out E> protected constructor(protected val impl: PSet<@UnsafeVariance E>) : ImmutableSet<E> {
+internal abstract class AbstractImmutableSet<out E> protected constructor(protected val impl: PSet<@UnsafeVariance E>) : PersistentSet<E> {
 
     override val size: Int get() = impl.size
     override fun isEmpty(): Boolean = impl.isEmpty()
@@ -31,23 +31,23 @@ internal abstract class AbstractImmutableSet<out E> protected constructor(protec
     override fun hashCode(): Int = impl.hashCode()
     override fun toString(): String = impl.toString()
 
-    override fun add(element: @UnsafeVariance E): ImmutableSet<E> = wrap(impl.plus(element))
+    override fun add(element: @UnsafeVariance E): PersistentSet<E> = wrap(impl.plus(element))
 
-    override fun addAll(elements: Collection<@UnsafeVariance E>): ImmutableSet<E> = wrap(impl.plusAll(elements))
+    override fun addAll(elements: Collection<@UnsafeVariance E>): PersistentSet<E> = wrap(impl.plusAll(elements))
 
-    override fun remove(element: @UnsafeVariance E): ImmutableSet<E> = wrap(impl.minus(element))
+    override fun remove(element: @UnsafeVariance E): PersistentSet<E> = wrap(impl.minus(element))
 
-    override fun removeAll(elements: Collection<@UnsafeVariance E>): ImmutableSet<E> = mutate { it.removeAll(elements) }
+    override fun removeAll(elements: Collection<@UnsafeVariance E>): PersistentSet<E> = mutate { it.removeAll(elements) }
 
-    override fun removeAll(predicate: (E) -> Boolean): ImmutableSet<E> = mutate { it.removeAll(predicate) }
+    override fun removeAll(predicate: (E) -> Boolean): PersistentSet<E> = mutate { it.removeAll(predicate) }
 
     override abstract fun clear(): AbstractImmutableSet<E>
 
     override abstract fun builder(): Builder<@UnsafeVariance E>
 
     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>) : AbstractMutableSet<E>(), ImmutableSet.Builder<E> {
+    abstract class Builder<E> internal constructor(protected var value: AbstractImmutableSet<E>, protected var impl: PSet<E>) : AbstractMutableSet<E>(), PersistentSet.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/ImmutableCollection.kt

@@ -16,21 +16,23 @@
 
 package kotlinx.collections.immutable
 
-public interface ImmutableCollection<out E>: Collection<E> {
-    fun add(element: @UnsafeVariance E): ImmutableCollection<E>
+public interface ImmutableCollection<out E>: Collection<E>
 
-    fun addAll(elements: Collection<@UnsafeVariance E>): ImmutableCollection<E>
+public interface PersistentCollection<out E> : ImmutableCollection<E> {
+    fun add(element: @UnsafeVariance E): PersistentCollection<E>
 
-    fun remove(element: @UnsafeVariance E): ImmutableCollection<E>
+    fun addAll(elements: Collection<@UnsafeVariance E>): PersistentCollection<E>
 
-    fun removeAll(elements: Collection<@UnsafeVariance E>): ImmutableCollection<E>
+    fun remove(element: @UnsafeVariance E): PersistentCollection<E>
 
-    fun removeAll(predicate: (E) -> Boolean): ImmutableCollection<E>
+    fun removeAll(elements: Collection<@UnsafeVariance E>): PersistentCollection<E>
 
-    fun clear(): ImmutableCollection<E>
+    fun removeAll(predicate: (E) -> Boolean): PersistentCollection<E>
+
+    fun clear(): PersistentCollection<E>
 
     interface Builder<E>: MutableCollection<E> {
-        fun build(): ImmutableCollection<E>
+        fun build(): PersistentCollection<E>
     }
 
     fun builder(): Builder<@UnsafeVariance E>

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

@@ -23,7 +23,7 @@ internal class ImmutableHashMap<K, out V> private constructor(impl: PMap<K, V>)
     override fun wrap(impl: PMap<K, @UnsafeVariance V>): ImmutableHashMap<K, V>
             = if (this.impl === impl) this else ImmutableHashMap(impl)
 
-    override fun clear(): ImmutableMap<K, V> = emptyOf()
+    override fun clear(): PersistentMap<K, V> = emptyOf()
 
     override fun builder(): Builder<K, @UnsafeVariance V> = Builder(this, impl)
 

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

@@ -16,36 +16,63 @@
 
 package kotlinx.collections.immutable
 
-public interface ImmutableList<out E>: List<E>, ImmutableCollection<E> {
-    override fun add(element: @UnsafeVariance E): ImmutableList<E>
+import kotlinx.collections.immutable.internal.ListImplementation
 
-    override fun addAll(elements: Collection<@UnsafeVariance E>): ImmutableList<E> // = super<ImmutableCollection>.addAll(elements) as ImmutableList
+public interface ImmutableList<out E> : List<E>, ImmutableCollection<E> {
 
-    override fun remove(element: @UnsafeVariance E): ImmutableList<E>
+    override fun subList(fromIndex: Int, toIndex: Int): ImmutableList<E> = SubList(this, fromIndex, toIndex)
 
-    override fun removeAll(elements: Collection<@UnsafeVariance E>): ImmutableList<E>
+    public class SubList<E>(private val source: ImmutableList<E>, private val fromIndex: Int, private val toIndex: Int) : ImmutableList<E>, AbstractList<E>() {
+        private var _size: Int = 0
 
-    override fun removeAll(predicate: (E) -> Boolean): ImmutableList<E>
+        init {
+            ListImplementation.checkRangeIndexes(fromIndex, toIndex, source.size)
+            this._size = toIndex - fromIndex
+        }
 
-    override fun clear(): ImmutableList<E>
+        override fun get(index: Int): E {
+            ListImplementation.checkElementIndex(index, _size)
 
+            return source[fromIndex + index]
+        }
 
-    fun addAll(index: Int, c: Collection<@UnsafeVariance E>): ImmutableList<E> // = builder().apply { addAll(index, c.toList()) }.build()
+        override val size: Int get() = _size
 
-    fun set(index: Int, element: @UnsafeVariance E): ImmutableList<E>
+        override fun subList(fromIndex: Int, toIndex: Int): ImmutableList<E> {
+            ListImplementation.checkRangeIndexes(fromIndex, toIndex, this._size)
+            return SubList(source, this.fromIndex + fromIndex, this.fromIndex + toIndex)
+        }
+
+    }
+}
+
+public interface PersistentList<out E> : ImmutableList<E>, PersistentCollection<E> {
+    override fun add(element: @UnsafeVariance E): PersistentList<E>
+
+    override fun addAll(elements: Collection<@UnsafeVariance E>): PersistentList<E> // = super<ImmutableCollection>.addAll(elements) as ImmutableList
+
+    override fun remove(element: @UnsafeVariance E): PersistentList<E>
+
+    override fun removeAll(elements: Collection<@UnsafeVariance E>): PersistentList<E>
+
+    override fun removeAll(predicate: (E) -> Boolean): PersistentList<E>
+
+    override fun clear(): PersistentList<E>
+
+
+    fun addAll(index: Int, c: Collection<@UnsafeVariance E>): PersistentList<E> // = builder().apply { addAll(index, c.toList()) }.build()
+
+    fun set(index: Int, element: @UnsafeVariance E): PersistentList<E>
 
     /**
      * Inserts an element into the list at the specified [index].
      */
-    fun add(index: Int, element: @UnsafeVariance E): ImmutableList<E>
-
-    fun removeAt(index: Int): ImmutableList<E>
-
+    fun add(index: Int, element: @UnsafeVariance E): PersistentList<E>
 
-    override fun subList(fromIndex: Int, toIndex: Int): ImmutableList<E>
+    fun removeAt(index: Int): PersistentList<E>
 
-    interface Builder<E>: MutableList<E>, ImmutableCollection.Builder<E> {
-        override fun build(): ImmutableList<E>
+    interface Builder<E>: MutableList<E>, PersistentCollection.Builder<E> {
+        override fun build(): PersistentList<E>
     }
 
     override fun builder(): Builder<@UnsafeVariance E>

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

@@ -19,28 +19,29 @@ package kotlinx.collections.immutable
 
 public interface ImmutableMap<K, out V>: Map<K, V> {
 
-    override val keys: Set<K>
+    override val keys: ImmutableSet<K>
+
+    override val values: ImmutableCollection<V>
+
+    override val entries: ImmutableSet<Map.Entry<K, V>>
+}
 
-    override val values: Collection<V>
 
-    override val entries: Set<Map.Entry<K, V>>
 
-    fun put(key: K, value: @UnsafeVariance V): ImmutableMap<K, V>
+public interface PersistentMap<K, out V> : ImmutableMap<K, V> {
+    fun put(key: K, value: @UnsafeVariance V): PersistentMap<K, V>
 
-    fun remove(key: K): ImmutableMap<K, V>
+    fun remove(key: K): PersistentMap<K, V>
 
-    fun remove(key: K, value: @UnsafeVariance V): ImmutableMap<K, V>
+    fun remove(key: K, value: @UnsafeVariance V): PersistentMap<K, V>
 
-    fun putAll(m: Map<out K, @UnsafeVariance V>): ImmutableMap<K, V>  // m: Iterable<Map.Entry<K, V>> or Map<out K,V> or Iterable<Pair<K, V>>
+    fun putAll(m: Map<out K, @UnsafeVariance V>): PersistentMap<K, V>  // m: Iterable<Map.Entry<K, V>> or Map<out K,V> or Iterable<Pair<K, V>>
 
-    fun clear(): ImmutableMap<K, V>
+    fun clear(): PersistentMap<K, V>
 
     interface Builder<K, V>: MutableMap<K, V> {
-        fun build(): ImmutableMap<K, V>
+        fun build(): PersistentMap<K, V>
     }
 
     fun builder(): Builder<K, @UnsafeVariance V>
 }
-
-
-