inline fun CharSequence.forEachCodePoint(
    start: Int = 0, end: Int = length,
    action: (index: Int, codePoint: Int) -> Unit
) {
    var i = start
    var codePoint: Int
    while (i < end) {
        codePoint = Character.codePointAt(this, i);
        action(i, codePoint)
        i += Character.charCount(codePoint)
    }
}

filter

filterNot

@OptIn(ExperimentalTime::class)
class DateTimeSource(val time: OffsetDateTime) : AbstractLongTimeSource(unit = DurationUnit.MILLISECONDS), TimeSource {
    override fun read(): Long {
        return time.toInstant().toEpochMilli()
    }
}

fun <C : Comparable<C>> C.coerceAtMost(maxValue: C) = if (this > maxValue) maxValue else this
fun <C : Comparable<C>> C.coerceAtLeast(minValue: C) = if (this < minValue) minValue else this
fun <C : Comparable<C>> C.coerceIn(minValue: C, maxValue: C) = coerceAtLeast(minValue).coerceAtMost(maxValue)

fun <C : Comparable<C>> min(vararg elements: C): C
fun <C : Comparable<C>> max(vararg elements: C): C

val a = b?.c.toString()

b == null

a != null

a == "null"

val a = b?.c?.toString()

fun List<E>.subListAfterFirst(element: E): List<E>

fun List<E>.subListAfterLast(element: E): List<E>

KType

public fun <T> MutableList<T>.removeAll(predicate: (T) -> Boolean): Boolean = filterInPlace(predicate, true)

private fun <T> MutableList<T>.filterInPlace(predicate: (T) -> Boolean, predicateResultToRemove: Boolean): Boolean {
    if (this !is RandomAccess)
        return (this as MutableIterable<T>).filterInPlace(predicate, predicateResultToRemove)

    var writeIndex: Int = 0
    for (readIndex in 0..lastIndex) {
        val element = this[readIndex]
    ...
        if (writeIndex != readIndex)
            this[writeIndex] = element
     ...
}

CopyOnWriteArrayList.removeAll

fun Iterable<String>.sortedWith(collator: Collator) = this.map { collator.getCollationKey(it) }.sorted().map { it.sourceString }

Flow.toList()

Stream.toList()

val myString = "%.1f".format(myFloat)

format

java.text.NumberFormat

buildList

Iterable<T>

list.validatedFold

n

n+1

list.flatMapIndexedNotNull

fun main() {
    val number = 0.001 * 0.001
    println(number.toString())
    // prints 1.0E-6
}

Reader

@JvmThrows

String.getOrNul(index: Int): Char

nul

\u0000

org.jetbrains.kotlin.utils.addToStdlib

cast

safeAs

Map<K, V>.getOrElse

mapOf("1" to null).getOrElse("1") { error("missing") }

containsKey("1")

true

getOrElseNullable

() -> Item

map { it() }

map((()->Item)::invoke)