Is there a function in the kotlin stdlib to split a list into a list of sublists with a predicate to choose where to separate each sublist, and where the result preserves the order of elements.

List::chunked

doesn’t do what I want, nor does

List::windowed

.  E.g. if I have a list, x = [“a”, “b”, “C”, “d”, “E”, “F”, “g”] and I want to split it into sublists where the case is the same within the sublist, I could pass in a predicate to this function something like…

x.split { x, b -> a.isUpperCase() != b.isUpperCase() }

giving me:

[["a", "b"], ["C"], ["d"], ["E", "F"], ["g"]]

I often need this operation, but always end up writing it with imperative code.  Is there something in the stdlib I’m missing.

In this case you can use

x.partition { it.isUpperCase() }

What I gather from that thread is that (a) there is no such function, and (b) groupBy does not do what I need.

another use case for https://youtrack.jetbrains.com/issue/KT-8280

I don’t think it is

x.groupConsecutiveBy { it.isUpperCase() }

(or whatever it is named, if it existed) would give you the same groupings you asked for

For this specific case, which is just an illustrative example

For my actual use case, I need to compare consecutive elements to decide whether to split the list between them (edited)

That's sort of the opposite of a functional pattern, which is probably why there's no builtin stdlib function that's generalizable

inefficient (due to Map) hack (due to mutation), but works:

private object Sentinel@Suppress("UNCHECKED_CAST")
fun <T> Iterable<T>.splitWhen(predicate: (T, T) -> Boolean): List<List<T>> {
    var last: Any? = Sentinel
    var counter = 0
    return groupBy {
        if (last !is Sentinel && predicate(last as T, it)) {
            counter++
        }
        last = it
        counter
    }.values.toList()
}

efficient (by streaming) but prone to misuse (breaks if inner sequence is not iterated exactly once fully):

private object Sentinel
@Suppress("UNCHECKED_CAST")
fun <T> Sequence<T>.splitWhen(predicate: (T, T) -> Boolean): Sequence<Sequence<T>> = sequence {
    var next: Any? = Sentinel
    val iterator = this@splitWhen.iterator()
    while (next !== Sentinel || iterator.hasNext()) {
        yield(sequence loop@{
            for (item in iterator) {
                val last = next
                next = item
                if (last !== Sentinel) {
                    yield(last as T)
                    if (predicate(last, item)) return@loop
                }
            }
            if (next !== Sentinel) yield((next as T).also { next = Sentinel })
        })
    }
}

either way I don't see an elegant functional solution

@Paul Griffith I don’t know why you think it’s “the opposite of a functional pattern”. The function is in the standard library of languages that are more functional than Kotlin, such as Clojure.

What is you actual use case then? How do you compare consecutive elements? What is the name of that function in Clojure?

The consecutive elements are passed to the predicate.

Haskell doesn't have a function like this -

Data.List.groupBy

is close, but it always performs comparisons between the first item of a group and the item to be considered (in your original example, it'll compare "a" and "C", not "b" and "C")

You’re right. I was thinking of partition by in Clojure. In Kotlin we have windowed and zipWithNext which apply a function consecutive elements of a collection, and then the elements can be combined into sublists with a fold. I worry that using fold to collect into Java lists will involve a lot of copying, so use imperative code and a list builder instead.

the sequence version I left earlier could be easily made resilient against misuse just by list-ifying it, e.g.

fun <T> Iterable<T>.splitWhen(predicate: (T, T) -> Boolean): List<List<T>> = this.asSequence().splitWhen(predicate).map { it.toList() }.toList()

or avoiding Sequence by building the lists in-line, as you mentioned