private val _listOfStrings = mutableListOf<String>()
val listOfStrings : List<String> = _listOfStrings
// and 
private val _listOfStrings = mutableListOf<String>()
val listOfStrings : List<String> 
    get() = _listOfStrings

run

?:

fun takesNullables(val string: String?) {
    val notNull = string ?: run {
        println("arg was null")
        return
    }
}

// Or a more complicated usage 
fun gaurdTest(val nums: List<Int>, val person: Person) {
    val firstEvent = nums.firstOrNull { it % 2 == 0 } ?: run {
        println("no evens in $nums")
        return
    }
    // Or 
    val streetName = person?.address?.streeName ?: run {
        println("street name not found")
        return
    }
}

fun addStatement(statement: Statement?){
	statement?.let{
		statements.add(it)
	}
}

fun addStatement(statement: Statement?){
	statement?:return
	statements.add(statement)
}

fun addStatement(statement: Statement?){
	if(statement != null)
		statements.add(statement)
}

fooExt.kt

FooExt.kt

// 1
fun calculateHour(h: Int, period: String?): Int =
  period?.let {
    when(it) {
      "am" -> if (h == HOURS_PER_PERIOD) 0 else h
      "pm" -> (h % HOURS_PER_PERIOD) + HOURS_PER_PERIOD
      else -> h // should not happen
    }
  } ?: h
}

// 2
fun calculateHour(h: Int, period: String?): Int =
  if (period == null) {
    h
  } else when (period) {
    "am" -> if (h == HOURS_PER_PERIOD) 0 else h
    "pm" -> (h % HOURS_PER_PERIOD) + HOURS_PER_PERIOD
    else -> h // should not happen
  }
}

val things = getThings() orIfEmpty listOf(SingleThing())

val things = getThings().letIfEmpty { listOf(SingleThing()) }

Flow

fun users() : Flow<List<User>>
or
fun observeUsers() : Flow<List<User>>
or
fun usersChanges() : Flow<List<User>>
or 
fun getUsersStream() : Flow<List<User>>

name

sealed class Things {
    abstract val name: String

    data class ThingA(val x: Int, val y: String) : Things() {
        override val name = "foo"
    }

    data class ThingB(z: Double) : Things() {
        override val name = "bar"
    }
}

sealed class Things(val name: String) {
    data class ThingA(val x: Int, val y: String) : Things("foo")

    data class ThingB(z: Double) : Things("bar")
}

.not()

!

!

!=

(a == b).not()

// 1
override fun onCreateLoader(loaderId: Int, args: Bundle?): Loader<Cursor> {
    val nickname = viewModel.nickname
    return CursorLoader(
        contactActivity,
        ContactsContract.Contacts.CONTENT_URI,
        PROJECTION,
        SELECTION,
        arrayOf(
            nickname, // just the nickname
            "$nickname %", // first name
            "% $nickname", // last name
            "% $nickname %" // middle name
        ),
        null
    )
}

// 2
override fun onCreateLoader(loaderId: Int, args: Bundle?) =
    viewModel.nickname.let { nickname ->
        CursorLoader(
            contactActivity,
            ContactsContract.Contacts.CONTENT_URI,
            PROJECTION,
            SELECTION,
            arrayOf(
                nickname, // just the nickname
                "$nickname %", // first name
                "% $nickname", // last name
                "% $nickname %" // middle name
            ),
            null
        )
    }

val string: String? = "possibly-null"

val stringOrEmpty: String = string ?: ""

val stringOrEmpty: String = string.orEmpty()

.toString()

Object#toString

checkNotNull(x).also {
    // do something like..
    it.prop = y
    // ...
}

x?.apply {
    // do something like..
    it.prop = y
    // ...
} ?: throw IllegalStateException()

// Why is it that we are encouraged to add spaces before EVERY lambda?
// Seems to me like the spaces arbitrarily break up this expression.
list.filter { it < 10 }.map { it * it }

// This is the long-form syntax, right?
list.filter({ it < 10 }).map({ it * it })

// So after a little syntactic sugar, we should end up like this?
list.filter{ it < 10 }.map{ it * it }

.let

.let

val numbers = listOf("one", "two", "three", "four")
val modifiedFirstItem = numbers.first().let { firstItem ->
    println("The first item of the list is '$firstItem'")
    if (firstItem.length >= 5) firstItem else "!" + firstItem + "!"
}.toUpperCase()
println("First item after modifications: '$modifiedFirstItem'")

val numbers = listOf("one", "two", "three", "four")
numbers.first().let { firstItem ->
   	println("The first item of the list is '$firstItem'")
   	if (firstItem.length >= 5) firstItem else "!" + firstItem + "!"
}.toUpperCase().let { modifiedFirstItem ->
	println("First item after modifications: '$modifiedFirstItem'")        
}

.let

fun CurrencyCode(value: String): CurrencyCode         // throws if invalid
fun CurrencyCodeOrNull(value: String): CurrencyCode?  // null if invalid

fun CurrencyCode.Companion.parse(value: String): CurrencyCode         // throws if invalid
fun CurrencyCode.Companion.parseOrNull(value: String): CurrencyCode?  // null if invalid

fun String.toCurrencyCode(): CurrencyCode         // throws if invalid
fun String.toCurrencyCodeOrNull(): CurrencyCode?  // null if invalid

Either

Future

map

Either

null

interface Foo
interface FooProvider { fun provide(): Foo? }

fun provideFoo(providers: List<FooProvider>): Foo? {
	for (provider in providers)
		provider.provide()?.let { return it }

	return null
}

providers.firstNonNullMapped { it.provide() }

Json {}

import bla.bla.*

a.id == b.id

a.id == b.id && a.prop1 == b.prop1 && …

equals

if (sender != recipient) sendNotification(…)

Set<Entity>

data class

val old: Collection<User>

val new: Collection<User>

old != new

distinctUntilChanged()

sender

recipient

sender != recipient

Flow<Collection<T>>.distinctUntilChanged { old, new -> … }

=

Unit

or

val json =
    obj or
    array or
    string or
    number

val json =
    obj or
        array or
        string or
        number

val json = obj or array or string or number

private fun setupPinKeypad() {
        binding.pinCodeLayout.btn0.text = ZERO.toString()
        binding.pinCodeLayout.btn1.text = ONE.toString()
        binding.pinCodeLayout.btn2.text = TWO.toString()
        binding.pinCodeLayout.btn3.text = THREE.toString()
        binding.pinCodeLayout.btn4.text = FOUR.toString()
        binding.pinCodeLayout.btn5.text = FIVE.toString()
        binding.pinCodeLayout.btn6.text = SIX.toString()
        binding.pinCodeLayout.btn7.text = SEVEN.toString()
        binding.pinCodeLayout.btn8.text = EIGHT.toString()
        binding.pinCodeLayout.btn9.text = NINE.toString()
    }

val filter: QueryFilter? = null

class QueryFilter(val by: String, val operator: String, val value: String)

filter.let {
                    mapOf(Pair("q[${<http://it.by|it.by>}_${it.operator}]", it.value))
                } ?: emptyMap()

val filter: Array<QueryFilter> = emptyArray()

filter.let { it ->
                    it.forEach {
                        mapOf(Pair("q[${<http://it.by|it.by>}_${it.operator}]", it.value))
                    }
                }
            }) as Map<String, String>

create

fun add(vararg s: String): String =
    s.joinToString(" ")

fun create(one: String, two: String, three: String): String {
    val m = mapOf(
        one to "one case",
        two to "two case",
        three to "three case",
        "" to ""
    )
    return add(m[one]!!, m[two]!!, m[three]!!)
}

when

if