{

let

as

:

takesAmbiguousType([1, 2, 3] : Set<Int>) // OK
takesAmbiguousType([1, 2, 3] : Array<Int>) // OK

Configuration(val host: String, val port: Int, val filters: List<Filter>)

Map<String, List<Configuration>>

private val _events: ReplaySubject<Thing>
val events: Observable<Thing>
    get = _events

private val events: ReplaySubject<Thing>
    public get(): Observable

return

init

@

@Named("coins") Safe coinSafe;
@Named("jewelry") Safe jewelrySafe;

Named

typealias

typealias CoinSafe = @Named("coins") Safe
typealias JewelrySafe = @Named("jewelry") Safe

// and usage becomes
CoinSafe coinSafe;
JewelrySafe jewelrySafe;

typealias

implement

override

Person(
    name = run {
      // some complicated things
      "Nathan"
    },
    
    age = run {
      // some complicated things
      17
    }
)

data class Foo(val bar: String, val baz: String = "baz")

// somewhere later
val bazValue = getBazValue() ?: Unset
Foo(
  bar = "bar",
  baz = bazValue
)

Unset

Unset

"Hello $name"

StringTemplate

String

interface StringTemplate {
    val placeholders: List<String>
    fun getValue(placeholder: String): Any?
    fun toString(mapper: (@ParameterName("name") String, @ParameterName("value") Any?) -> Any?): String
}

interface Flippable<T> {
	fun flip(): T
}

extend String as Flippable<String> {
	// Implements all of the Flippable properties/methods missing from the base class
	fun flip(): String {
		...
	}
}

String

Flippable

if (title == null) title = tmdbEpisode.name

title ?= thing

||=

catch

try { ... } catch { it.printStackTrace() }

it

try { ... } catch { err -> ... }

handle

catch

catch

topLevelFun() = Unit

class Foo {
    bar() {
        //
    }
    baz() = println("baz")
}

Int64Size

Size

AutoCloseable