前要素と比較してぶったぎる関数

partitionByComparingPredecessor.ts

export function partitionByComparingPredecessor<T>(
    list: T[], partition: (prev: T, cur: T) => boolean
): T[][] {

    const result: T[][] = []

    let prev: T = null
    let accum: T[] = []

    for (const cur of list) {
        if (prev !== null) {
            if (partition(prev, cur)) {
                result.push(accum)
                accum = []
            }
        }
        prev = cur
        accum.push(cur)
    }

    if (accum.length > 0) {
        result.push(accum)
    }

    return result
}

fun <T> List<T>.partitionByComparingPredecessor(
    partition: (prev: T, cur: T) -> Boolean
): List<List<T>> {

    val result = mutableListOf<List<T>>()

    var prev: T? = null
    var accum = mutableListOf<T>()

    for (cur in this) {
        if (prev !== null) {
            if (partition(prev, cur)) {
                result.add(accum)
                accum = mutableListOf<T>()
            }
        }

        prev = cur
        accum.add(cur)
    }

    if (accum.size > 0) {
        result.add(accum)
    }

    return result
}