kollections-interoperable/kollections/MutableList

MutableList

@Serializable(with = MutableListSerializer::class)

interface MutableList<E> : List<E> , MutableList<E> , MutableCollection<E>

Inheritors

Queue

Functions

add

abstract override fun add(element: E): Boolean

abstract fun add(index: Int, element: E)

addAll

abstract override fun addAll(elements: Collection<E>): Boolean

abstract fun addAll(index: Int, elements: Collection<E>): Boolean

associate

abstract fun <K2, V2> associate(transformer: (E) -> MapEntry<K2, V2>): Map<K2, V2>

clear

abstract override fun clear()

contains

abstract operator override fun contains(element: E): Boolean

containsAll

abstract fun containsAll(elements: Collection<E>): Boolean

filter

abstract fun filter(predicate: (E) -> Boolean): List<E>

first

abstract fun first(): E

firstOrNull

abstract fun firstOrNull(): E?

forEach

abstract fun forEach(lambda: (item: E) -> Unit)

forEachWithIndex

abstract fun forEachWithIndex(lambda: (item: E, index: Int) -> Unit)

get

abstract operator override fun get(index: Int): E

indexOf

abstract override fun indexOf(element: E): Int

isEmpty

abstract override fun isEmpty(): Boolean

iterator

abstract operator fun iterator(): Iterator<E>

lastIndexOf

abstract override fun lastIndexOf(element: E): Int

listIterator

abstract fun listIterator(): ListIterator<E>

abstract fun listIterator(index: Int): ListIterator<E>

map

abstract fun <R> map(transform: (item: E) -> R): List<R>

mapToArray

abstract fun <R> mapToArray(transform: (item: E) -> R): Array<R>

mapToArrayWithIndex

abstract fun <R> mapToArrayWithIndex(transform: (item: E, index: Int) -> R): Array<R>

mapWithIndex

abstract fun <R> mapWithIndex(transform: (item: E, index: Int) -> R): List<R>

remove

abstract override fun remove(element: E): Boolean

removeAll

abstract override fun removeAll(elements: Collection<E>): Boolean

removeAt

abstract fun removeAt(index: Int): E

retainAll

abstract override fun retainAll(elements: Collection<E>): Boolean

set

abstract operator fun set(index: Int, element: E): E

subList

abstract fun subList(fromIndex: Int, toIndex: Int): List<E>

toIList

inline fun <E> Collection<E>.toIList(): List<E>

toIMutableList

inline fun <E> Collection<E>.toIMutableList(): MutableList<E>

toIMutableSet

inline fun <E> Collection<E>.toIMutableSet(): MutableSet<E>

toISet

inline fun <E> Collection<E>.toISet(): Set<E>

Properties

size

abstract override val size: Int