generated._Sequences.kt Maven / Gradle / Ivy

Go to download
@file:kotlin.jvm.JvmMultifileClass
@file:kotlin.jvm.JvmName("SequencesKt")

package kotlin

//
// NOTE THIS FILE IS AUTO-GENERATED by the GenerateStandardLib.kt
// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib
//

import java.util.*

import java.util.Collections // TODO: it's temporary while we have java.util.Collections in js

/**
 * Returns `true` if [element] is found in the sequence.
 */
public operator fun <@kotlin.internal.OnlyInputTypes T> Sequence.contains(element: T): Boolean {
    return indexOf(element) >= 0
}

/**
 * Returns `true` if [element] is found in the collection.
 */
@Deprecated("Sequence and element have incompatible types. Upcast element to Any? if you're sure. Replacement will be provided in beta4.")
@kotlin.jvm.JvmName("containsAny")
@kotlin.internal.LowPriorityInOverloadResolution
public operator fun  Sequence.contains(element: T): Boolean {
    return contains(element)
}

/**
 * Returns `true` if [element] is found in the sequence.
 * Allows to overcome type-safety restriction of `contains` that requires to pass an element of type `T`.
 */
@Suppress("NOTHING_TO_INLINE")
public inline fun Sequence<*>.containsRaw(element: Any?): Boolean {
    return contains(element)
}

/**
 * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this sequence.
 */
public fun  Sequence.elementAt(index: Int): T {
    return elementAtOrElse(index) { throw IndexOutOfBoundsException("Sequence doesn't contain element at index $index.") }
}

/**
 * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this sequence.
 */
public fun  Sequence.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T {
    if (index < 0)
        return defaultValue(index)
    val iterator = iterator()
    var count = 0
    while (iterator.hasNext()) {
        val element = iterator.next()
        if (index == count++)
            return element
    }
    return defaultValue(index)
}

/**
 * Returns an element at the given [index] or `null` if the [index] is out of bounds of this sequence.
 */
public fun  Sequence.elementAtOrNull(index: Int): T? {
    if (index < 0)
        return null
    val iterator = iterator()
    var count = 0
    while (iterator.hasNext()) {
        val element = iterator.next()
        if (index == count++)
            return element
    }
    return null
}

/**
 * Returns the first element matching the given [predicate], or `null` if no such element was found.
 */
public inline fun  Sequence.find(predicate: (T) -> Boolean): T? {
    return firstOrNull(predicate)
}

/**
 * Returns the last element matching the given [predicate], or `null` if no such element was found.
 */
public inline fun  Sequence.findLast(predicate: (T) -> Boolean): T? {
    return lastOrNull(predicate)
}

/**
 * Returns first element.
 * @throws [NoSuchElementException] if the sequence is empty.
 */
public fun  Sequence.first(): T {
    val iterator = iterator()
    if (!iterator.hasNext())
        throw NoSuchElementException("Sequence is empty.")
    return iterator.next()
}

/**
 * Returns the first element matching the given [predicate].
 * @throws [NoSuchElementException] if no such element is found.
 */
public inline fun  Sequence.first(predicate: (T) -> Boolean): T {
    for (element in this) if (predicate(element)) return element
    throw NoSuchElementException("No element matching predicate was found.")
}

/**
 * Returns the first element, or `null` if the sequence is empty.
 */
public fun  Sequence.firstOrNull(): T? {
    val iterator = iterator()
    if (!iterator.hasNext())
        return null
    return iterator.next()
}

/**
 * Returns the first element matching the given [predicate], or `null` if element was not found.
 */
public inline fun  Sequence.firstOrNull(predicate: (T) -> Boolean): T? {
    for (element in this) if (predicate(element)) return element
    return null
}

/**
 * Returns first index of [element], or -1 if the sequence does not contain element.
 */
public fun <@kotlin.internal.OnlyInputTypes T> Sequence.indexOf(element: T): Int {
    var index = 0
    for (item in this) {
        if (element == item)
            return index
        index++
    }
    return -1
}

/**
 * Returns first index of [element], or -1 if the collection does not contain element.
 */
@Deprecated("Sequence and element have incompatible types. Upcast element to Any? if you're sure. Replacement will be provided in beta4.")
@kotlin.jvm.JvmName("indexOfAny")
@kotlin.internal.LowPriorityInOverloadResolution
@Suppress("NOTHING_TO_INLINE")
public fun  Sequence.indexOf(element: T): Int {
    return indexOf(element)
}

/**
 * Returns index of the first element matching the given [predicate], or -1 if the sequence does not contain such element.
 */
public inline fun  Sequence.indexOfFirst(predicate: (T) -> Boolean): Int {
    var index = 0
    for (item in this) {
        if (predicate(item))
            return index
        index++
    }
    return -1
}

/**
 * Returns index of the last element matching the given [predicate], or -1 if the sequence does not contain such element.
 */
public inline fun  Sequence.indexOfLast(predicate: (T) -> Boolean): Int {
    var lastIndex = -1
    var index = 0
    for (item in this) {
        if (predicate(item))
            lastIndex = index
        index++
    }
    return lastIndex
}

/**
 * Returns first index of [element], or -1 if the sequence does not contain element.
 * Allows to overcome type-safety restriction of `indexOf` that requires to pass an element of type `T`.
 */
@Suppress("NOTHING_TO_INLINE")
public inline fun Sequence<*>.indexOfRaw(element: Any?): Int {
    return indexOf(element)
}

/**
 * Returns the last element.
 * @throws [NoSuchElementException] if the sequence is empty.
 */
public fun  Sequence.last(): T {
    val iterator = iterator()
    if (!iterator.hasNext())
        throw NoSuchElementException("Sequence is empty.")
    var last = iterator.next()
    while (iterator.hasNext())
        last = iterator.next()
    return last
}

/**
 * Returns the last element matching the given [predicate].
 * @throws [NoSuchElementException] if no such element is found.
 */
public inline fun  Sequence.last(predicate: (T) -> Boolean): T {
    var last: T? = null
    var found = false
    for (element in this) {
        if (predicate(element)) {
            last = element
            found = true
        }
    }
    if (!found) throw NoSuchElementException("Collection doesn't contain any element matching the predicate.")
    return last as T
}

/**
 * Returns last index of [element], or -1 if the sequence does not contain element.
 */
public fun <@kotlin.internal.OnlyInputTypes T> Sequence.lastIndexOf(element: T): Int {
    var lastIndex = -1
    var index = 0
    for (item in this) {
        if (element == item)
            lastIndex = index
        index++
    }
    return lastIndex
}

/**
 * Returns last index of [element], or -1 if the collection does not contain element.
 */
@Deprecated("Sequence and element have incompatible types. Upcast element to Any? if you're sure. Replacement will be provided in beta4.")
@kotlin.jvm.JvmName("lastIndexOfAny")
@kotlin.internal.LowPriorityInOverloadResolution
@Suppress("NOTHING_TO_INLINE")
public fun  Sequence.lastIndexOf(element: T): Int {
    return lastIndexOf(element)
}

/**
 * Returns last index of [element], or -1 if the sequence does not contain element.
 * Allows to overcome type-safety restriction of `lastIndexOf` that requires to pass an element of type `T`.
 */
@Suppress("NOTHING_TO_INLINE")
public inline fun Sequence<*>.lastIndexOfRaw(element: Any?): Int {
    return lastIndexOf(element)
}

/**
 * Returns the last element, or `null` if the sequence is empty.
 */
public fun  Sequence.lastOrNull(): T? {
    val iterator = iterator()
    if (!iterator.hasNext())
        return null
    var last = iterator.next()
    while (iterator.hasNext())
        last = iterator.next()
    return last
}

/**
 * Returns the last element matching the given [predicate], or `null` if no such element was found.
 */
public inline fun  Sequence.lastOrNull(predicate: (T) -> Boolean): T? {
    var last: T? = null
    for (element in this) {
        if (predicate(element)) {
            last = element
        }
    }
    return last
}

/**
 * Returns the single element, or throws an exception if the sequence is empty or has more than one element.
 */
public fun  Sequence.single(): T {
    val iterator = iterator()
    if (!iterator.hasNext())
        throw NoSuchElementException("Sequence is empty.")
    var single = iterator.next()
    if (iterator.hasNext())
        throw IllegalArgumentException("Sequence has more than one element.")
    return single
}

/**
 * Returns the single element matching the given [predicate], or throws exception if there is no or more than one matching element.
 */
public inline fun  Sequence.single(predicate: (T) -> Boolean): T {
    var single: T? = null
    var found = false
    for (element in this) {
        if (predicate(element)) {
            if (found) throw IllegalArgumentException("Collection contains more than one matching element.")
            single = element
            found = true
        }
    }
    if (!found) throw NoSuchElementException("Collection doesn't contain any element matching predicate.")
    return single as T
}

/**
 * Returns single element, or `null` if the sequence is empty or has more than one element.
 */
public fun  Sequence.singleOrNull(): T? {
    val iterator = iterator()
    if (!iterator.hasNext())
        return null
    var single = iterator.next()
    if (iterator.hasNext())
        return null
    return single
}

/**
 * Returns the single element matching the given [predicate], or `null` if element was not found or more than one element was found.
 */
public inline fun  Sequence.singleOrNull(predicate: (T) -> Boolean): T? {
    var single: T? = null
    var found = false
    for (element in this) {
        if (predicate(element)) {
            if (found) return null
            single = element
            found = true
        }
    }
    if (!found) return null
    return single
}

/**
 * Returns a sequence containing all elements except first [n] elements.
 */
public fun  Sequence.drop(n: Int): Sequence {
    require(n >= 0, { "Requested element count $n is less than zero." })
    return if (n == 0) this else DropSequence(this, n)
}

/**
 * Returns a sequence containing all elements except first elements that satisfy the given [predicate].
 */
public fun  Sequence.dropWhile(predicate: (T) -> Boolean): Sequence {
    return DropWhileSequence(this, predicate)
}

/**
 * Returns a sequence containing only elements matching the given [predicate].
 */
public fun  Sequence.filter(predicate: (T) -> Boolean): Sequence {
    return FilteringSequence(this, true, predicate)
}

/**
 * Returns a sequence containing only elements matching the given [predicate].
 */
public fun  Sequence.filterIndexed(predicate: (Int, T) -> Boolean): Sequence {
    // TODO: Rewrite with generalized MapFilterIndexingSequence
    return TransformingSequence(FilteringSequence(IndexingSequence(this), true, { predicate(it.index, it.value) }), { it.value })
}

/**
 * Appends all elements matching the given [predicate] to the given [destination].
 */
public inline fun > Sequence.filterIndexedTo(destination: C, predicate: (Int, T) -> Boolean): C {
    forEachIndexed { index, element ->
        if (predicate(index, element)) destination.add(element)
    }
    return destination
}

/**
 * Returns a sequence containing all elements not matching the given [predicate].
 */
public fun  Sequence.filterNot(predicate: (T) -> Boolean): Sequence {
    return FilteringSequence(this, false, predicate)
}

/**
 * Returns a sequence containing all elements that are not `null`.
 */
public fun  Sequence.filterNotNull(): Sequence {
    return filterNot { it == null } as Sequence
}

/**
 * Appends all elements that are not `null` to the given [destination].
 */
public fun , T : Any> Sequence.filterNotNullTo(destination: C): C {
    for (element in this) if (element != null) destination.add(element)
    return destination
}

/**
 * Appends all elements not matching the given [predicate] to the given [destination].
 */
public inline fun > Sequence.filterNotTo(destination: C, predicate: (T) -> Boolean): C {
    for (element in this) if (!predicate(element)) destination.add(element)
    return destination
}

/**
 * Appends all elements matching the given [predicate] to the given [destination].
 */
public inline fun > Sequence.filterTo(destination: C, predicate: (T) -> Boolean): C {
    for (element in this) if (predicate(element)) destination.add(element)
    return destination
}

/**
 * Returns a sequence containing first [n] elements.
 */
public fun  Sequence.take(n: Int): Sequence {
    require(n >= 0, { "Requested element count $n is less than zero." })
    return if (n == 0) emptySequence() else TakeSequence(this, n)
}

/**
 * Returns a sequence containing first elements satisfying the given [predicate].
 */
public fun  Sequence.takeWhile(predicate: (T) -> Boolean): Sequence {
    return TakeWhileSequence(this, predicate)
}

/**
 * Returns a sequence that yields elements of this sequence sorted according to their natural sort order.
 */
public fun > Sequence.sorted(): Sequence {
    return object : Sequence {
        override fun iterator(): Iterator {
            val sortedList = [email protected]()
            sortedList.sort()
            return sortedList.iterator()
        }
    }
}

/**
 * Returns a sequence that yields elements of this sequence sorted according to natural sort order of the value returned by specified [selector] function.
 */
public inline fun > Sequence.sortedBy(crossinline selector: (T) -> R?): Sequence {
    return sortedWith(compareBy(selector))
}

/**
 * Returns a sequence that yields elements of this sequence sorted descending according to natural sort order of the value returned by specified [selector] function.
 */
public inline fun > Sequence.sortedByDescending(crossinline selector: (T) -> R?): Sequence {
    return sortedWith(compareByDescending(selector))
}

/**
 * Returns a sequence that yields elements of this sequence sorted descending according to their natural sort order.
 */
public fun > Sequence.sortedDescending(): Sequence {
    return sortedWith(reverseOrder())
}

/**
 * Returns a sequence that yields elements of this sequence sorted according to the specified [comparator].
 */
public fun  Sequence.sortedWith(comparator: Comparator): Sequence {
    return object : Sequence {
        override fun iterator(): Iterator {
            val sortedList = [email protected]()
            sortedList.sortWith(comparator)
            return sortedList.iterator()
        }
    }
}

/**
 * Returns an [ArrayList] of all elements.
 */
public fun  Sequence.toArrayList(): ArrayList {
    return toCollection(ArrayList())
}

/**
 * Appends all elements to the given [destination] collection.
 */
public fun > Sequence.toCollection(destination: C): C {
    for (item in this) {
        destination.add(item)
    }
    return destination
}

/**
 * Returns a [HashSet] of all elements.
 */
public fun  Sequence.toHashSet(): HashSet {
    return toCollection(HashSet())
}

/**
 * Returns a [LinkedList] containing all elements.
 */
@Deprecated("Use toCollection(LinkedList()) instead.", ReplaceWith("toCollection(LinkedList())"))
public fun  Sequence.toLinkedList(): LinkedList {
    return toCollection(LinkedList())
}

/**
 * Returns a [List] containing all elements.
 */
public fun  Sequence.toList(): List {
    return this.toArrayList()
}

@Deprecated("Use toMapBy instead.", ReplaceWith("toMapBy(selector)"))
public inline fun  Sequence.toMap(selector: (T) -> K): Map {
    return toMapBy(selector)
}

/**
 * Returns Map containing the values provided by [transform] and indexed by [selector] functions applied to elements of the given sequence.
 * If any two elements would have the same key returned by [selector] the last one gets added to the map.
 */
public inline fun  Sequence.toMap(selector: (T) -> K, transform: (T) -> V): Map {
    val result = LinkedHashMap()
    for (element in this) {
        result.put(selector(element), transform(element))
    }
    return result
}

/**
 * Returns Map containing the elements from the given sequence indexed by the key
 * returned from [selector] function applied to each element.
 * If any two elements would have the same key returned by [selector] the last one gets added to the map.
 */
public inline fun  Sequence.toMapBy(selector: (T) -> K): Map {
    val result = LinkedHashMap()
    for (element in this) {
        result.put(selector(element), element)
    }
    return result
}

/**
 * Returns a [Set] of all elements.
 */
public fun  Sequence.toSet(): Set {
    return toCollection(LinkedHashSet())
}

/**
 * Returns a [SortedSet] of all elements.
 */
public fun > Sequence.toSortedSet(): SortedSet {
    return toCollection(TreeSet())
}

/**
 * Returns a [SortedSet] of all elements.
 * Elements in the set returned are sorted according to the given [comparator].
 */
@kotlin.jvm.JvmVersion
public fun  Sequence.toSortedSet(comparator: Comparator): SortedSet {
    return toCollection(TreeSet(comparator))
}

/**
 * Returns a single sequence of all elements from results of [transform] function being invoked on each element of original sequence.
 */
public fun  Sequence.flatMap(transform: (T) -> Sequence): Sequence {
    return FlatteningSequence(this, transform, { it.iterator() })
}

/**
 * Appends all elements yielded from results of [transform] function being invoked on each element of original sequence, to the given [destination].
 */
public inline fun > Sequence.flatMapTo(destination: C, transform: (T) -> Sequence): C {
    for (element in this) {
        val list = transform(element)
        destination.addAll(list)
    }
    return destination
}

/**
 * Returns a map of the elements in original sequence grouped by the key returned by the given [selector] function.
 */
public inline fun  Sequence.groupBy(selector: (T) -> K): Map> {
    return groupByTo(LinkedHashMap>(), selector)
}

/**
 * Appends elements from original sequence grouped by the key returned by the given [selector] function to the given [map].
 */
public inline fun  Sequence.groupByTo(map: MutableMap>, selector: (T) -> K): Map> {
    for (element in this) {
        val key = selector(element)
        val list = map.getOrPut(key) { ArrayList() }
        list.add(element)
    }
    return map
}

/**
 * Returns a sequence containing the results of applying the given [transform] function
 * to each element in the original sequence.
 */
public fun  Sequence.map(transform: (T) -> R): Sequence {
    return TransformingSequence(this, transform)
}

/**
 * Returns a sequence containing the results of applying the given [transform] function
 * to each element and its index in the original sequence.
 */
public fun  Sequence.mapIndexed(transform: (Int, T) -> R): Sequence {
    return TransformingIndexedSequence(this, transform)
}

/**
 * Returns a sequence containing only the non-null results of applying the given [transform] function
 * to each element and its index in the original sequence.
 */
public fun  Sequence.mapIndexedNotNull(transform: (Int, T) -> R?): Sequence {
    return TransformingIndexedSequence(this, transform).filterNotNull()
}

/**
 * Applies the given [transform] function to each element and its index in the original sequence
 * and appends only the non-null results to the given [destination].
 */
public inline fun > Sequence.mapIndexedNotNullTo(destination: C, transform: (Int, T) -> R?): C {
    forEachIndexed { index, element -> transform(index, element)?.let { destination.add(it) } }
    return destination
}

/**
 * Applies the given [transform] function to each element and its index in the original sequence
 * and appends the results to the given [destination].
 */
public inline fun > Sequence.mapIndexedTo(destination: C, transform: (Int, T) -> R): C {
    var index = 0
    for (item in this)
        destination.add(transform(index++, item))
    return destination
}

/**
 * Returns a sequence containing only the non-null results of applying the given [transform] function
 * to each element in the original sequence.
 */
public fun  Sequence.mapNotNull(transform: (T) -> R?): Sequence {
    return TransformingSequence(this, transform).filterNotNull()
}

/**
 * Applies the given [transform] function to each element in the original sequence
 * and appends only the non-null results to the given [destination].
 */
public inline fun > Sequence.mapNotNullTo(destination: C, transform: (T) -> R?): C {
    forEach { element -> transform(element)?.let { destination.add(it) } }
    return destination
}

/**
 * Applies the given [transform] function to each element of the original sequence
 * and appends the results to the given [destination].
 */
public inline fun > Sequence.mapTo(destination: C, transform: (T) -> R): C {
    for (item in this)
        destination.add(transform(item))
    return destination
}

/**
 * Returns a sequence of [IndexedValue] for each element of the original sequence.
 */
public fun  Sequence.withIndex(): Sequence> {
    return IndexingSequence(this)
}

/**
 * Returns a sequence containing only distinct elements from the given sequence.
 * The elements in the resulting sequence are in the same order as they were in the source sequence.
 */
public fun  Sequence.distinct(): Sequence {
    return this.distinctBy { it }
}

/**
 * Returns a sequence containing only elements from the given sequence
 * having distinct keys returned by the given [selector] function.
 * The elements in the resulting sequence are in the same order as they were in the source sequence.
 */
public fun  Sequence.distinctBy(selector: (T) -> K): Sequence {
    return DistinctSequence(this, selector)
}

/**
 * Returns a mutable set containing all distinct elements from the given sequence.
 */
public fun  Sequence.toMutableSet(): MutableSet {
    val set = LinkedHashSet()
    for (item in this) set.add(item)
    return set
}

/**
 * Returns `true` if all elements match the given [predicate].
 */
public inline fun  Sequence.all(predicate: (T) -> Boolean): Boolean {
    for (element in this) if (!predicate(element)) return false
    return true
}

/**
 * Returns `true` if sequence has at least one element.
 */
public fun  Sequence.any(): Boolean {
    for (element in this) return true
    return false
}

/**
 * Returns `true` if at least one element matches the given [predicate].
 */
public inline fun  Sequence.any(predicate: (T) -> Boolean): Boolean {
    for (element in this) if (predicate(element)) return true
    return false
}

/**
 * Returns the number of elements in this sequence.
 */
public fun  Sequence.count(): Int {
    var count = 0
    for (element in this) count++
    return count
}

/**
 * Returns the number of elements matching the given [predicate].
 */
public inline fun  Sequence.count(predicate: (T) -> Boolean): Int {
    var count = 0
    for (element in this) if (predicate(element)) count++
    return count
}

/**
 * Accumulates value starting with [initial] value and applying [operation] from left to right to current accumulator value and each element.
 */
public inline fun  Sequence.fold(initial: R, operation: (R, T) -> R): R {
    var accumulator = initial
    for (element in this) accumulator = operation(accumulator, element)
    return accumulator
}

/**
 * Performs the given [action] on each element.
 */
public inline fun  Sequence.forEach(action: (T) -> Unit): Unit {
    for (element in this) action(element)
}

/**
 * Performs the given [action] on each element, providing sequential index with the element.
 */
public inline fun  Sequence.forEachIndexed(action: (Int, T) -> Unit): Unit {
    var index = 0
    for (item in this) action(index++, item)
}

/**
 * Returns the largest element or `null` if there are no elements.
 */
public fun > Sequence.max(): T? {
    val iterator = iterator()
    if (!iterator.hasNext()) return null
    var max = iterator.next()
    while (iterator.hasNext()) {
        val e = iterator.next()
        if (max < e) max = e
    }
    return max
}

/**
 * Returns the first element yielding the largest value of the given function or `null` if there are no elements.
 */
public inline fun , T : Any> Sequence.maxBy(selector: (T) -> R): T? {
    val iterator = iterator()
    if (!iterator.hasNext()) return null
    var maxElem = iterator.next()
    var maxValue = selector(maxElem)
    while (iterator.hasNext()) {
        val e = iterator.next()
        val v = selector(e)
        if (maxValue < v) {
            maxElem = e
            maxValue = v
        }
    }
    return maxElem
}

/**
 * Returns the smallest element or `null` if there are no elements.
 */
public fun > Sequence.min(): T? {
    val iterator = iterator()
    if (!iterator.hasNext()) return null
    var min = iterator.next()
    while (iterator.hasNext()) {
        val e = iterator.next()
        if (min > e) min = e
    }
    return min
}

/**
 * Returns the first element yielding the smallest value of the given function or `null` if there are no elements.
 */
public inline fun , T : Any> Sequence.minBy(selector: (T) -> R): T? {
    val iterator = iterator()
    if (!iterator.hasNext()) return null
    var minElem = iterator.next()
    var minValue = selector(minElem)
    while (iterator.hasNext()) {
        val e = iterator.next()
        val v = selector(e)
        if (minValue > v) {
            minElem = e
            minValue = v
        }
    }
    return minElem
}

/**
 * Returns `true` if the sequence has no elements.
 */
public fun  Sequence.none(): Boolean {
    for (element in this) return false
    return true
}

/**
 * Returns `true` if no elements match the given [predicate].
 */
public inline fun  Sequence.none(predicate: (T) -> Boolean): Boolean {
    for (element in this) if (predicate(element)) return false
    return true
}

/**
 * Accumulates value starting with the first element and applying [operation] from left to right to current accumulator value and each element.
 */
public inline fun  Sequence.reduce(operation: (S, T) -> S): S {
    val iterator = this.iterator()
    if (!iterator.hasNext()) throw UnsupportedOperationException("Empty iterable can't be reduced.")
    var accumulator: S = iterator.next()
    while (iterator.hasNext()) {
        accumulator = operation(accumulator, iterator.next())
    }
    return accumulator
}

/**
 * Returns the sum of all values produced by [selector] function applied to each element in the sequence.
 */
public inline fun  Sequence.sumBy(selector: (T) -> Int): Int {
    var sum: Int = 0
    for (element in this) {
        sum += selector(element)
    }
    return sum
}

/**
 * Returns the sum of all values produced by [selector] function applied to each element in the sequence.
 */
public inline fun  Sequence.sumByDouble(selector: (T) -> Double): Double {
    var sum: Double = 0.0
    for (element in this) {
        sum += selector(element)
    }
    return sum
}

/**
 * Returns an original collection containing all the non-`null` elements, throwing an [IllegalArgumentException] if there are any `null` elements.
 */
public fun  Sequence.requireNoNulls(): Sequence {
    return map { it ?: throw IllegalArgumentException("null element found in $this.") }
}

/**
 * Returns a sequence containing all elements of the original sequence without the first occurrence of the given [element].
 */
public operator fun  Sequence.minus(element: T): Sequence {
    return object: Sequence {
        override fun iterator(): Iterator {
            var removed = false
            return [email protected] { if (!removed && it == element) { removed = true; false } else true }.iterator()
        }
    }
}

/**
 * Returns a sequence containing all elements of original sequence except the elements contained in the given [elements] array.
 * Note that the source sequence and the array being subtracted are iterated only when an `iterator` is requested from
 * the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
 */
public operator fun  Sequence.minus(elements: Array): Sequence {
    if (elements.isEmpty()) return this
    return object: Sequence {
        override fun iterator(): Iterator {
            val other = elements.toHashSet()
            return [email protected] { it in other }.iterator()
        }
    }
}

/**
 * Returns a sequence containing all elements of original sequence except the elements contained in the given [elements] collection.
 * Note that the source sequence and the collection being subtracted are iterated only when an `iterator` is requested from
 * the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
 */
public operator fun  Sequence.minus(elements: Iterable): Sequence {
    return object: Sequence {
        override fun iterator(): Iterator {
            val other = elements.convertToSetForSetOperation()
            if (other.isEmpty())
                return [email protected]()
            else
                return [email protected] { it in other }.iterator()
        }
    }
}

/**
 * Returns a sequence containing all elements of original sequence except the elements contained in the given [elements] sequence.
 * Note that the source sequence and the sequence being subtracted are iterated only when an `iterator` is requested from
 * the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
 */
public operator fun  Sequence.minus(elements: Sequence): Sequence {
    return object: Sequence {
        override fun iterator(): Iterator {
            val other = elements.toHashSet()
            if (other.isEmpty())
                return [email protected]()
            else
                return [email protected] { it in other }.iterator()
        }
    }
}

/**
 * Splits the original sequence into pair of lists,
 * where *first* list contains elements for which [predicate] yielded `true`,
 * while *second* list contains elements for which [predicate] yielded `false`.
 */
public inline fun  Sequence.partition(predicate: (T) -> Boolean): Pair, List> {
    val first = ArrayList()
    val second = ArrayList()
    for (element in this) {
        if (predicate(element)) {
            first.add(element)
        } else {
            second.add(element)
        }
    }
    return Pair(first, second)
}

/**
 * Returns a sequence containing all elements of the original sequence and then the given [element].
 */
public operator fun  Sequence.plus(element: T): Sequence {
    return sequenceOf(this, sequenceOf(element)).flatten()
}

/**
 * Returns a sequence containing all elements of original sequence and then all elements of the given [elements] array.
 * Note that the source sequence and the array being added are iterated only when an `iterator` is requested from
 * the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
 */
public operator fun  Sequence.plus(elements: Array): Sequence {
    return this.plus(elements.asList())
}

/**
 * Returns a sequence containing all elements of original sequence and then all elements of the given [elements] collection.
 * Note that the source sequence and the collection being added are iterated only when an `iterator` is requested from
 * the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
 */
public operator fun  Sequence.plus(elements: Iterable): Sequence {
    return sequenceOf(this, elements.asSequence()).flatten()
}

/**
 * Returns a sequence containing all elements of original sequence and then all elements of the given [elements] sequence.
 * Note that the source sequence and the sequence being added are iterated only when an `iterator` is requested from
 * the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
 */
public operator fun  Sequence.plus(elements: Sequence): Sequence {
    return sequenceOf(this, elements).flatten()
}

/**
 * Returns a sequence of pairs built from elements of both sequences with same indexes.
 * Resulting sequence has length of shortest input sequence.
 */
public infix fun  Sequence.zip(other: Sequence): Sequence> {
    return MergingSequence(this, other) { t1, t2 -> t1 to t2 }
}

/**
 * Returns a sequence of values built from elements of both collections with same indexes using provided [transform]. Resulting sequence has length of shortest input sequences.
 */
public fun  Sequence.zip(other: Sequence, transform: (T, R) -> V): Sequence {
    return MergingSequence(this, other, transform)
}

/**
 * Appends the string from all the elements separated using [separator] and using the given [prefix] and [postfix] if supplied.
 * If the collection could be huge, you can specify a non-negative value of [limit], in which case only the first [limit]
 * elements will be appended, followed by the [truncated] string (which defaults to "...").
 */
public fun  Sequence.joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((T) -> CharSequence)? = null): A {
    buffer.append(prefix)
    var count = 0
    for (element in this) {
        if (++count > 1) buffer.append(separator)
        if (limit < 0 || count <= limit) {
            if (transform != null)
                buffer.append(transform(element))
            else
                buffer.append(if (element == null) "null" else element.toString())
        } else break
    }
    if (limit >= 0 && count > limit) buffer.append(truncated)
    buffer.append(postfix)
    return buffer
}

@Deprecated("Provided for binary compatibility", level = DeprecationLevel.HIDDEN)
public fun  Sequence.joinTo(buffer: A, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...", transform: ((T) -> String)? = null): A {
    return joinTo(buffer, separator, prefix, postfix, limit, truncated, transform)
}

/**
 * Creates a string from all the elements separated using [separator] and using the given [prefix] and [postfix] if supplied.
 * If the collection could be huge, you can specify a non-negative value of [limit], in which case only the first [limit]
 * elements will be appended, followed by the [truncated] string (which defaults to "...").
 */
public fun  Sequence.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((T) -> CharSequence)? = null): String {
    return joinTo(StringBuilder(), separator, prefix, postfix, limit, truncated, transform).toString()
}

@Deprecated("Provided for binary compatibility", level = DeprecationLevel.HIDDEN)
public fun  Sequence.joinToString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...", transform: ((T) -> String)? = null): String {
    return joinTo(StringBuilder(), separator, prefix, postfix, limit, truncated, transform).toString()
}

/**
 * Returns a sequence from the given collection.
 */
public fun  Sequence.asSequence(): Sequence {
    return this
}

/**
 * Returns a sequence containing all elements that are instances of specified type parameter R.
 */
@kotlin.jvm.JvmVersion
public inline fun  Sequence<*>.filterIsInstance(): Sequence<@kotlin.internal.NoInfer R> {
    return filter { it is R } as Sequence
}

/**
 * Returns a sequence containing all elements that are instances of specified class.
 */
@kotlin.jvm.JvmVersion
public fun  Sequence<*>.filterIsInstance(klass: Class): Sequence {
    return filter { klass.isInstance(it) } as Sequence
}

/**
 * Appends all elements that are instances of specified type parameter R to the given [destination].
 */
@kotlin.jvm.JvmVersion
public inline fun > Sequence<*>.filterIsInstanceTo(destination: C): C {
    for (element in this) if (element is R) destination.add(element)
    return destination
}

/**
 * Appends all elements that are instances of specified class to the given [destination].
 */
@kotlin.jvm.JvmVersion
public fun , R> Sequence<*>.filterIsInstanceTo(destination: C, klass: Class): C {
    for (element in this) if (klass.isInstance(element)) destination.add(element as R)
    return destination
}

/**
 * Returns an average value of elements in the sequence.
 */
@kotlin.jvm.JvmName("averageOfByte")
public fun Sequence.average(): Double {
    val iterator = iterator()
    var sum: Double = 0.0
    var count: Int = 0
    while (iterator.hasNext()) {
        sum += iterator.next()
        count += 1
    }
    return if (count == 0) 0.0 else sum / count
}

/**
 * Returns an average value of elements in the sequence.
 */
@kotlin.jvm.JvmName("averageOfDouble")
public fun Sequence.average(): Double {
    val iterator = iterator()
    var sum: Double = 0.0
    var count: Int = 0
    while (iterator.hasNext()) {
        sum += iterator.next()
        count += 1
    }
    return if (count == 0) 0.0 else sum / count
}

/**
 * Returns an average value of elements in the sequence.
 */
@kotlin.jvm.JvmName("averageOfFloat")
public fun Sequence.average(): Double {
    val iterator = iterator()
    var sum: Double = 0.0
    var count: Int = 0
    while (iterator.hasNext()) {
        sum += iterator.next()
        count += 1
    }
    return if (count == 0) 0.0 else sum / count
}

/**
 * Returns an average value of elements in the sequence.
 */
@kotlin.jvm.JvmName("averageOfInt")
public fun Sequence.average(): Double {
    val iterator = iterator()
    var sum: Double = 0.0
    var count: Int = 0
    while (iterator.hasNext()) {
        sum += iterator.next()
        count += 1
    }
    return if (count == 0) 0.0 else sum / count
}

/**
 * Returns an average value of elements in the sequence.
 */
@kotlin.jvm.JvmName("averageOfLong")
public fun Sequence.average(): Double {
    val iterator = iterator()
    var sum: Double = 0.0
    var count: Int = 0
    while (iterator.hasNext()) {
        sum += iterator.next()
        count += 1
    }
    return if (count == 0) 0.0 else sum / count
}

/**
 * Returns an average value of elements in the sequence.
 */
@kotlin.jvm.JvmName("averageOfShort")
public fun Sequence.average(): Double {
    val iterator = iterator()
    var sum: Double = 0.0
    var count: Int = 0
    while (iterator.hasNext()) {
        sum += iterator.next()
        count += 1
    }
    return if (count == 0) 0.0 else sum / count
}

/**
 * Returns the sum of all elements in the sequence.
 */
@kotlin.jvm.JvmName("sumOfByte")
public fun Sequence.sum(): Int {
    val iterator = iterator()
    var sum: Int = 0
    while (iterator.hasNext()) {
        sum += iterator.next()
    }
    return sum
}

/**
 * Returns the sum of all elements in the sequence.
 */
@kotlin.jvm.JvmName("sumOfDouble")
public fun Sequence.sum(): Double {
    val iterator = iterator()
    var sum: Double = 0.0
    while (iterator.hasNext()) {
        sum += iterator.next()
    }
    return sum
}

/**
 * Returns the sum of all elements in the sequence.
 */
@kotlin.jvm.JvmName("sumOfFloat")
public fun Sequence.sum(): Float {
    val iterator = iterator()
    var sum: Float = 0.0f
    while (iterator.hasNext()) {
        sum += iterator.next()
    }
    return sum
}

/**
 * Returns the sum of all elements in the sequence.
 */
@kotlin.jvm.JvmName("sumOfInt")
public fun Sequence.sum(): Int {
    val iterator = iterator()
    var sum: Int = 0
    while (iterator.hasNext()) {
        sum += iterator.next()
    }
    return sum
}

/**
 * Returns the sum of all elements in the sequence.
 */
@kotlin.jvm.JvmName("sumOfLong")
public fun Sequence.sum(): Long {
    val iterator = iterator()
    var sum: Long = 0L
    while (iterator.hasNext()) {
        sum += iterator.next()
    }
    return sum
}

/**
 * Returns the sum of all elements in the sequence.
 */
@kotlin.jvm.JvmName("sumOfShort")
public fun Sequence.sum(): Int {
    val iterator = iterator()
    var sum: Int = 0
    while (iterator.hasNext()) {
        sum += iterator.next()
    }
    return sum
}