sumOf{..}: Float

Number.toDouble()

buildString

buildList { ... add(..) }.joinToString(" ")

buildString(" ") { ... add(...) }

StringJoiner

java.nio.file.Path

PathTreeWalk

FileTreeWalk

walkFileTree()

Sequence

public inline fun <T1, T2: Comparable<T2>> compareBy(crossinline selector: (T1) -> T2): Comparator<T1> =
        Comparator { a, b -> selector(a).compareTo(selector(b)) }

public inline fun <T> compareBy(crossinline selector: (T) -> Comparable<*>?): Comparator<T> =
    Comparator { a, b -> compareValuesBy(a, b, selector) }

compareBy

Benchmark                                           (N)  Mode  Cnt  Score   Error  Units
ComparatorBenchmarkPrimitiveHelper.maxKt         100000  avgt   10  2.824 ± 0.102  ms/op
ComparatorBenchmarkPrimitiveHelper.maxPrimitive  100000  avgt   10  0.381 ± 0.155  ms/op

compareBy

sortBy

sortedBy

maxBy

sortBy

maxBy

ClosedRange<T>.mapBounds()

val range = 1 .. 10
val shiftedRange = range.mapBounds { it + 10 } // = 11 .. 20
val characters = "a" .. "z"
val uppercaseCharacters = characters.mapBounds { it.toUpperCase() } // == "A" .. "Z"

fun <T : Comparable<T>, R : Comparable<R>> ClosedRange<T>.mapBounds(transform: (T) -> R): ClosedRange<R> =
    transform(start) .. transform(endInclusive)

// plus overloads for primitive ranges

MutableList.removeLast

Unresolved reference: removeLast

repeat

val created = repeat(n){ create_something()}

(1..n).map{ create_something() }

fun <T> repeat(n:Int, builder: (Int) -> T) = (1..n).map{ builder(it)}

Set<T>.map {}

List

Set

map.merge

map.getOrDefault(key){ ... build default value lazily here .. }

require

kotlin.random.Random.Default

listOf(1,2,3).shuffled()

public fun <T> maxOf(a: T, vararg other: T, comparator: Comparator<in T>): T

public actual fun <T : Comparable<T>> maxOf(a: T, vararg other: T): T

T

: Comparable<T>

comparator

vararg

sort

Comparable

Comparator

Order

(Double.NaN == Double.NaN).let(::println) // false
(listOf(Double.NaN) == listOf(Double.NaN)).let(::println) // true

String.toCamelCase()

String.toSnakeCase

inline fun succeeded(block: () -> Unit): Boolean {
    return try {
        block()
        true
    } catch (e: Exception) {
        false
    }
}

List

List(size = 1) { "foo" }
sequence { yield("foo") }

Number

if(it<0) 0 else it

buildList

buildSet

buildMap

String.replaceLast

String.replaceFirst

fun Int.coerceIn(minMax: Int): Int {
    val abs = minMax.absoluteValue
    return coerceIn(-abs, abs)
}