fun Context.color(@ColorInt color: Int) = ContextCompat.getColor(this, color)

fun Date.Companion.factoryExtension() {
    
}

this

class Matrix {
    ...
    operator fun get(r: Int, c: Int) = ...
    
    inner object Transpose {
        operator fun get(r: Int, c: Int) = this@Matrix.get(c, r)
    }
}

class Matrix {
   val transpose by lazy { Transpose() }
   ...
   inner class Transpose {
      ...
   }
}

lateinit

interface Foo {
    val bar: Int
    fun getBaz(): Int
}

class Spam: Foo {
    override fun getBar() = 0
    override val baz get() = 0
}

enum class Bit {
    ZERO, ONE
}

fun test(bit: Bit): Int {
    if (bit == Bit.ZERO) {
        return 0
    }
    return when (bit) {
        Bit.ONE -> 1
    }
}

when

when

runCatching

names.groupBy { it.length }

names.groupBy(String::length)

names.groupBy(::length)

::length

names.groupBy(.length)

names.groupBy(_.length)

names.group_by(&:length)

val str = "a😀cde"
    val start = str.indexOf(str.first()) + 2
    val end = str.indexOf(str.last()) - 2
    val range = IntRange(start, end)
    println(str.substring(range)) // "should output 😀c, but will output ?c"

asUnit()

override someMethodReturningJavaVoidOrUnit() = launch { ... }.asUnit()

class Foo private constructor(private val barImpl: Bar): Bar by barImpl {
    constructor() : this(BarImpl())
}

inline fun <T, K> Sequence<T>.groupByAndReduce(keySelector: (T) -> K, crossinline reducer: (T, T) -> T): Map<K, T> =
        groupByAndReduceTo(LinkedHashMap(), keySelector, reducer)

inline fun <T, K, M : MutableMap<in K, T>> Sequence<T>.groupByAndReduceTo(destination: M, keySelector: (T) -> K, crossinline reducer: (T, T) -> T): M {
    for (element in this) {
        val k = keySelector(element)
        destination.compute(k) { _, v -> if (v == null) element else reducer(v, element) }
    }
    return destination
}

inline fun <T, A, K> Sequence<T>.groupByAndFold(keySelector: (T) -> K, seedValue: A, crossinline folder: (A, T) -> A): Map<K, A> =
        groupByAndFoldTo(LinkedHashMap(), keySelector, seedValue, folder)

inline fun <T, A, K, M : MutableMap<in K, A>> Sequence<T>.groupByAndFoldTo(destination: M, keySelector: (T) -> K, seedValue: A, crossinline folder: (A, T) -> A): M {
    for (element in this) {
        val k = keySelector(element)
        destination.compute(k) { _, v -> folder(v ?: seedValue, element) }
    }
    return destination
}

FunctionX

typealias Interceptor<T, U> = (Store<T, U>, U, Interceptor<T, U>) -> Unit  // Cannot be done

interface Interceptor<T, U> : (Store<T, U>, U, Interceptor<T, U>) -> Unit

fun <T, U> test(interceptor: Interceptor<T, U>) { ... }

// You have to do this
test(object: Interceptor<String, Int> {
    override fun invoke(store: Store<String, Int>, value: Int, interceptor: Interceptor<String, Int> {
        ...
    }
})

// I would like to do this
test<String, Int> { store, value, interceptor -> ... }

Android Kotlin Guidelines

,

data class Test (
        val param1:String,
        val param2:String,
        val param3:String,
        val param4:String
)

data class Test (
        val param1:String
        val param2:String
        val param3:String
        val param4:String
)

Inline classes are similar to type aliases, but they are not assignment-compatible with the underlying value type, so you cannot assign a String to a variable of type Name, and vice versa.

Name

String

inline class Name(val value: String)
val name = Name("Jerzy")

// old API that still uses raw String
fun greet(val name: String)

// the way we'd call the method with Name
greet(name.value)

greet(name)

String

weak var something: Something? = someRef //of type WeakReference<Something> 
if (something == null) { /*True if something's reference is null*/ } 
var inferredWeakSomething = something //of type WeakReference<Something>
strong var strongSomething = something //of type Something?

[1,2,3]