What would you think about an indexed `Sequence.ta...

# stdlib

[smichel17]

What would you think about an indexed Sequence.takeWhile? E.g. one of these:

fun <T>Sequence<T>.takeThenWhile(count: Int, predicate: (T) -> Boolean): Sequence<T> {
    var i = 0
    return this.takeWhile{ i < count || predicate(it) }.onEach { i++ }
}


fun <T>Sequence<T>.takeWhileIndexed(predicate: (Int, T) -> Boolean): Sequence<T> {
    var i = 0
    return takeWhile { predicate(i, it) }.onEach { i++ }
}

Both take and takeWhile could be implemented in terms of this function

fun <T>Sequence<T>.take(count: Int) = takeThenWhile(count) { false }
fun <T>Sequence<T>.takeWhile(predicate: (T) -> Boolean) = takeThenWhile(0, predicate)

fun <T>Sequence<T>.take(count: Int) = takeWhileIndexed { i, _ -> i < count }
fun <T>Sequence<T>.takeWhile(predicate: (T) -> Boolean) = takeWhileIndexed { _, t -> predicate(t) }

[gian]

Why not using withIndex()?

sequenceOf("a").withIndex().takeWhile { (index, value) -> }

[smichel17]

derp, that works; I missed withIndex 😅

[smichel17]

Hmm, although in this case I need to get back to the raw values anyway, and I'm not sure that I like having to wrap and then unwrap each value to do that, it's basically

fun <T>Sequence<T>.takeThenWhile(count: Int, predicate: (T) -> Boolean): Sequence<T> {
    return withIndex().takeWhile{ (i, t) -> i < count || predicate(t) }.map { it.value }
}

[ephemient]

btw using a mutable var like that is not good, if the sequence is iterated over multiple times

[smichel17]

It won't be set separately for each invocation?

[smichel17]

(In my usage, it's only iterated once, but I'd like to leave a comment if that's something to consider in the future)

[ephemient]

not if val s = .takeWhileIndexed(); s.forEach(); s.forEach(). you could use the sequence builder,

fun <T> Sequence<T>.takeWhileIndexed(count: Int, predicate: (Int, T) -> Boolean): Sequence<T> = sequence {
    if (count <= 0) return@sequence
    var i = 0
    for (item in this@takeWhileIndexed) {
        if (!predicate(i, item)) break
        yield(item)
        if (++i >= count) break
    }
}

in which case the variable is scoped to each iterator

[ephemient]

that being said, how is your takeWhileThen any different from .take.takeWhile?

[ephemient]

oh I see, || not &&

[smichel17]

*`takeThenWhile` . I could name it more descriptively as takeThenTakeWhile.

[smichel17]

The usage is

private fun <T> Sequence<T>.countUnique(minItems: Int, uniqueValues: Int): Map<T, Int> {
    val counts = mutableMapOf<T, Int>()
    val items = takeThenWhile(minItems) { counts.size < uniqueValues }.filterNotNull()
    return items.groupingBy { it }.eachCountTo(counts)
}

[smichel17]

Counts the first minItems , but if it finds fewer than uniqueValues , it'll keep going until it finds that many (or the sequence ends, obviously)

[smichel17]

And the use case for that is https://github.com/streetcomplete/StreetComplete/pull/3373

[smichel17]

I think regular old take might have the same problem with double iteration? https://github.com/JetBrains/kotlin/blob/b65c477e68d2e4e3b635d63b7cdc61f41829d472/libraries/stdlib/src/kotlin/collections/Sequences.kt#L397 (The actual extension function is just slightly larger than Sequence.take(n: Int) = TakeSequence(this, n) )

[smichel17]

Renamed to takeAtLeastWhile :)

[ephemient]

stdlib take is fine, it's doing the same thing at a lower level

[ephemient]

https://pl.kotl.in/COEDuMty8

[smichel17]

Oh, I think I see. The sdlib is safe because it creates a new iterator (on line 411— when I originally read it, I missed that it was a function call, not a property access). And I guess sequence {} does the same thing.