val o = Option.just(1)

val i: Int = when (o) {
    is Some -> {
        val (value) = o
        value
    }
    else -> 0
}

val i: Int = when (o) {
    is Some(value) -> value
    else -> 0
}

is

function() { args ->
    // Blah
}

function(curried -> args -> {
    // Blah
})

function() { curried ->
    { args ->
        // Blah
    }
}

function() { curried -> args ->
    // Blah
}

val x = ::main

val x = main

else

else

filter

map

items.filter { ... }.map { ... }

filter

items.asSequence().filter { ... }.map { ... }

Sequence

mutableListOf<T>().apply { items.forEach { item -> if (...) add(...) } }

Sequence

inline interface Stream<T> { // inline here means that all implementations must be inline, and it should be possible to determine the implementation of any given Stream at compile-time
    fun forEach(operation: (T) -> Unit)
}

inline class IterableStream<T>(private val iterable: Iterable<T>): Stream<T> {
    override fun forEach(operation: (T) -> Boolean) {
        iterable.forEach { if (!operation(it)) return }
    }

}

inline class FilteringStream<T>(private val sourceStream: Stream<T>, private inline val predicate: (T) -> Boolean): Stream<T> {
    override fun forEach(operation: (T) -> Boolean) {
        sourceStream.forEach { item: T ->
            if (predicate(item)) {
                operation(item)
            } else {
                true
            }
        }
    }
}

inline class TransformingStream<T, R>(private val sourceStream: Stream<T>, private inline val transformer: (T) -> R): Stream<R> {
    override fun forEach(operation: (R) -> Boolean) {
        sourceStream.forEach { item: T ->
            operation(transformer(item))
        }
    }
}

inline fun <T> Iterable<T>.asStream() = IterableStream(this)
inline fun <T> Stream<T>.filter(predicate: (T) -> Boolean) = FilteringStream(this, predicate)
inline fun <T, R> Stream<T>.map(transformer: (T) -> R) = TransformingStream(this, transformer)
inline fun <T> Stream<T>.toList() {
    val list = ArrayList<T>()
    forEach { item -> list.add(item) }
}

val processedItemNames = items
        .asStream()
        .filter { it.isProcessed }
        .map { it.name }
        .toList()

val processedItemNames = ArrayList<String>()
items.forEach { item -> if (item.isProcessed) processedItemNames.add(item.name) }

Stream

zip

Stream

Iterable

Sequence

_

fun

interface Animal

class Dog : Animal
class Cat : Animal

fun randomAnimal(callback: (Animal) -> Unit) {
    callback.invoke(Dog())
}

fun main() {
    // Directly casting parameter to specific type when
    // declaring lambda parameters
    randomAnimal { animal as Dog -> // pay your attention. Here we cast Animal to Dog
        // Do something with dog...
    }

    // Safe cast sample
    randomAnimal { animal as? Dog -> // safe cast Animal to Dog
       animal?.let { 
           // Do something with dog...
       }
    }
}

invoke

Unit

fun doSomething(() -> Unit)

fun doSomething(suspend () -> Unit)

() -> Unit

suspend () -> Unit

Function0

doSomething(intList: List<Int>)

doSomething(stringList: List<String>)

sealed typealias Pet = Dog | Cat | String

when (somePet) {
  is Dog ->
  is Cat ->
  is String -> 
}

emptyMutableMap()

open class Generic<T: Any> private constructor(
   private val type: KType
) {

   inline <reified T> constructor():
      this(type = typeOf<T>())
}

Any

toBoolean()

true

class MyCounter(var cnt: Int = 0) {
  override toBoolean() = cnt > 0
}
var counter: MyCounter? = null
if(counter) // -> false
...
counter = MyCounter()
if(counter) -> false
..
counter.cnt++
if(counter) -> true
..

equals()

hashCode()

toString()

Any

Data

equals()

toString()

"MyClass@6ea12c19"

Any

java.lang.Object

::finalize

::clone

Any

override

Any.equals(...)

equals

===

Any.toString()

fun Data?.toString() = this?.toString() ?: "null"

@Deprecated("Does not have a useful String representation")
fun Any.toString() = (this as java.lang.Object).toString()

@Deprecated("Does not have a useful String representation")
fun Any?.toString() = this?.toString() ?: "null"

override

val Application.cronUsername by this.environment.config

this

Application

!

/.

@

->

{1, "2", a}

listOf(1, "2", a)

N[
	D[
		Normal[
			Series[
				Integrate[
					Zeta[x],
					x
                ],
				{x, 0, 6}
            ]
        ],
		{x, 2}
    ] /.x -> 15,
	10
]

val x = "x"

n(
	d(
		normal(
			series(
				integrate(
					zeta(x),
					x
				),
				{x, 0, 6}
			)
		),
		{x, 2}
	) /. x -> 15,
	10
)!

n

d

normal

toString

/.

->

+

-

val x = "x"

!n(
	d(
		normal(
			series(
				integrate(
					zeta(x),
					x
				),
				listOf(x, 0, 6)
			)
		),
		listOf(x, 2)
	) + "/. $x -> 15",
	10
)

@

@@

/.

->

@

@@

{1, "2", a}

listOf(1, "2", a)

constexpr

val encryptedStringExample by encryptedString { "Some_Secret" }

constexpr

println(encryptedStringExample) // Some_Secret

constexpr

Any?

Any?

inline fun foo(action: String = "Unknown", f: (bar: String) -> Any?): String {
    f("TESTING")
    return "DONE"
}

fun doSomething() {
    var k : Int = 0;
    foo(action = "DoSomething") {
        // Empty lambda's return type seen as Unit
    }
}

fun doSomething() {
    var k : Int = 0;
    foo(action = "DoSomething") {
        k++ // return type seen as Int
    }
}

fun doSomething() {
    var k : Int = 0;
    foo(action = "DoSomething") {
        k = k + 1      // <<--- "Expected a value of type Any?"
    }
}

fun doSomething() {
    var k : Int = 0;
    foo(action = "DoSomething") {
        k = k + 1
        
        "Garbage value to please compiler" // now it compiles fine, return type seen as String
    }
}

Concerning Unit, 6.6.3 of spec says -  "...This type may be used as a return type of any function that does not return any meaningful value."  I think lambdas and blocks whose last statement is an assignment qualify as not returning any meaningful value.

List

interface Base {
    fun print()
}

class BaseImpl(val x: Int) : Base {
    override fun print() { print(x) }
}

class Derived(val b: List<Base>) : Base by b
// or maybe use varargs
class Derived(vararg val b: Base) : Base by b

Derived

public

internal

inline fun <reified T: Application> launch() = Application.launch(T::class.java)

launch<MyApp>()

MyApp.lauch()