String.rangesOf.kt

fun CharSequence.indicesOf(pattern: String): Sequence<Int> = sequence {
    var startIndex = 0
    while (true) {
        startIndex = indexOf(pattern, startIndex)
        if (startIndex < 0) break
        yield(startIndex)
        startIndex += pattern.length
    }
}

fun CharSequence.rangesOf(pattern: String): Sequence<IntRange> =
        indicesOf(pattern).map { it until it + pattern.length }

fun CharSequence.rangesOf(patterns: Iterable<String>): Sequence<IntRange> =
        patterns.flatMapAsSequence { rangesOf(it) }

fun CharSequence.withRangesOf(patterns: Iterable<String>): Sequence<Pair<String, IntRange>> =
        patterns.flatMapAsSequence { pattern -> rangesOf(pattern).map { pattern to it } }

fun CharSequence.withTripleRangesOf(patterns: Iterable<String>): Sequence<Triple<String, Int, Int>> =
        withRangesOf(patterns).map { Triple(it.first, it.second.first, it.second.last) }

fun CharSequence.selections(patterns: Iterable<String>): Sequence<Triple<Boolean, CharSequence, IntRange>> =
        indices.ranges(
                rangesOf(patterns.sortedByDescending { it.length })
                        .distinctBy { it.first }
                        .sortedBy { it.first }
                        .asIterable()
        ).map { Triple(it.first, substring(it.second), it.second) }