equals()

Button(
    label = "Print count",
    onClick = @Equatable { println(count) }
)

data class ButtonProps(val label: String, val onClick: () -> Unit)

val onClick = useCallback(count) { println(count) }

count

@Equatable

equals

count

else

fun main():Unit{
    var a = 5
    when(a){
        1,2-> print("Case 1")
        5,else -> print("Fallback")
    }	
}

class SomeClass() {
    infix fun SomeClass.someFunction (someParam: SomeType) {
        // some code
    }
}

fun inSomeClass(action: SomeClass.() -> Unit) {
    SomeClass().action()
}

inSomeClass { 
    this someFunction "param"
    someFunction "param" // Receiver could possibly implied
}

where

when

@JvmOverloads

reified

inline

interface Box<out Value> { val value: Value }
class IntBox(override val value: Int): Box<Int>

val value: IntBox.Value = 1 // IntBox.Value is basically an alias for Int

interface Operation<out Result>

interface OperationExecutor<in TOperation : Operation<*>> {
    suspend fun execute(operation: TOperation): TOperation.Result // <<< here
}


class IntToStringOperation(val value: Int) : Operation<String>

object IntToStringOperationExecutor : OperationExecutor<IntToStringOperation> {

    override suspend fun execute(operation: IntToStringOperation): String =
        operation.value.toString()
}

interface OperationExecutor<TOperation : Operation<Result>, Result>

object IntToStringOperationExecutor : OperationExecutor<IntToStringOperation, Int>

val Foo.property = "foo"

private const val _foo = "foo"
val Foo.property get() = _foo

// avoid that value changes
val Foo.staticProperty = generateRandomId()

 // avoid repeated expensive computation
val Foo.expensiveProperty = someExpensiveSetup()

 // avoid temporary object creation
val Foo.someComplexData = SomeComplexData(…)
val Foo.someDependentProp1 get() = someComplexData.prop1
val Foo.someDependentProp2 get() = someComplexData.prop2
val Foo.someDependentProp3 get() = someComplexData.prop3
val Foo.someDependentProp4 get() = someComplexData.prop4

Foo

this

object

object

companion object

interface WithCompanion<T : Any>

fun <T : Any> companionOf(instance: WithCompanion<T>): T =
    TODO() // intrinsic

interface FooInterface: WithCompanion<Any>

fun bar(foo: FooInterface) {
   val companion: Any = companionOf(foo)
   // …
}

// Types implement `Event` must also have their companion implement `Event.Type`
interface Event : WithCompanion<Event.Type> {
    interface Type {
        val id: String
    }
}

// We can get the companion of an Event instance without reflection.
val Event.type get() = companionOf(this)

// Example
class SunriseEvent : Event {
    companion object : Event.Type {
        override val id = "sunrise"
    }
}

fun storeEvent(event: Event) {
     // Not possible like this at the moment without manually adding `type` to every single class implementing `Event` 
    val typeId = event.type.id
    // …
}

object

equals

hashCode

object

interface Foo {
    override fun equals(other: Any?): Boolean
    override fun hashCode(): Int
}

data class Bar1(val bar: Int) : Foo // fine
object Bar2 : Foo // error because equals() and hashCode() are missing

equals

hashCode

data class

object

data

typealias

typealias ViewModelInject = Inject(param1 = param1, param2 = param2, ...) // doesn't work

typealias ViewModelInject = Inject

sealed class Input<A> {
  object ForInt : Input<Int>()
  object ForString : Input<String>()
  object ForDouble : Input<Double>()
}

fun <A> process(input: Input<A>): A = when(input) {
  ForInt -> fetchInt() // returns Int
  ForString -> fetchString() // returns String
  ForDouble -> fetchDouble() // returns Double
}

@Suppress("UNCHECKED_CAST")
fun <A> process(input: Input<A>): A = when(input) {
    ForInt -> fetchInt() // returns Int
    ForString -> fetchString() // returns String
    ForDouble -> fetchDouble() // returns Double
} as A

inline fun <T> identity(block: () -> T): () -> T = block
inline fun <T> perform(block: () -> T): T = block()
fun main() {
    println(perform(identity { "hello" })
}

identity

suspend

inline

inline

inline

fun main () {
    println("hello")
}

inline fun <T> identity(block: () -> T): T = block()
inline fun <T> perform(block: () -> T): T = identity(block)
fun main() {
    println(perform { "hello" })
}

val shouldPerform = true
val shouldRunSpecial = true 
inline fun <T> specialLogic(block: () -> T): () -> T? = if(shouldRunSpecial) block else { null } // can also be converted to one big lambda instead that does the check on shouldRunSpecial when it's actually called like this: = { if(shouldRunSpecial) block() else null }. Those 2 styles should be roughly equal in the end since all the lambdas get inlined
inline fun <T> performOrThrow(block: () -> T): T = if(shouldPerform) block() else TODO()
fun main() {
    println(perform(specialLogic { "hello" })
}
// Turns into this:
fun main() {
    println(
        if(shouldPerform) {
            if (shouldRunSpecial) "hello" 
            else null 
        } 
        else TODO())
}

fun interface Functor

inline fun interface

fun interface

inline fun interface

inline fun interface

throwing

throw

class FakeConnection : java.sql.Connection by throwing {
  override fun prepareCall(sql: String) {
    // ... some assertion.
  } 
}

sealed class Download
data class App(val name: String, val developer: Developer) : Download()
data class Movie(val title: String, val director: Person) : Download()
val download: Download = // ...

// placeholder syntax
val result = when(download) {
  is App(.name, .developer: Person(val devName = .name))
    if (devName == "Alice") -> "Alice's app $name"
  is Movie(.title, .director: Person(val dirName = .name))
    if (dirName == "Alice") -> "Alice's movie $name"
  is App, Movie -> "Not by Alice"
}

.

&

:

.name

when

<deconstruct>()

Regex("\\s\\\\")

r"\s\\"

private typealias Binding = ItemRotaBinding

private typealias Binding = ItemShiftBinding

get

set

get

set

class Thing<T>(...) {
    operator fun set(coordinates: IntArray, depth: Int = this.depth, isDestructive: Boolean = true, value: T) { ... }
}

thing[coordinates] = value

thing[coordinates, isDestructive = false] = value

set

thing[coordinates, thing.depth, false] = value

thing.depth

set

measureTimedValue

TimedValue

@ExperimentalTime
inline fun <T> TimedValue<T>.capture(block: (Duration) -> Unit): T {
    block(duration)
    return value
}

@ExperimentalTime
fun main() {
    // Without the capture function
    val (result, duration) = measureTimedValue {
        Thread.sleep(500)
        "foobar"
    }
    println("Duration: $duration")
    println("Result: $result")


    // With the capture function
    measureTimedValue {
        Thread.sleep(500)
        "foobar"
    }.capture {
        println("Duration: $it")
    }.also {
        println("Result: $it")
    }
}

capture

fun f(a: A, b: B): T = TODO()

fun g(a: A?, b: B?) {
    val x = f(a?, b?)
}

x

T?

null

null

fun g(a: A?, b: B?) {
    val x = a?.let { actualA -> b?.let { actualB -> f(actualA, actualB) } }
}

fun g(a: A?, b: B?) {
    val x = if (a != null && b != null) f(a, b) else null
}

a

b

var

fun g(a: A?, b: B?) {
    val x = a?.let { b?.let { f(a, b) } }
}

a

b

var

interface SomeTrait { ... }

private class SomeTraitImpl(...) : SomeTrait { ... }

fun SomeTrait(...): SomeTrait = SomeTraitImpl(...)

class MyClass : SomeTrait by SomeTrait(...)

// Or just used to get an instance of the default implementation:
val trait = SomeTrait(...)

interface SomeTrait {
    ...

    default class(...) { // Optional name, like companion objects. Implicitly implements SomeTrait.
        ...
    }
}

// No need for a pseudo-constructor function:
val trait = SomeTrait(...) // gets an instance of the default class

class MyClass : SomeTrait(...)

// Desugars to:
class MyClass : SomeTrait by SomeTrait(...)

*Impl

2.days or Duration.days(2)

val timeToFix: Duration = .days(2)

fun something(r: Result<String>) { }

something(.success("Hello")

companion object

\n

\r\n

println("""\
This is the first line in this \
multi-line string.

This is the second line in this \
multi-line string.
""")

This is the first line in this multi-line string.

This is the second line in this multi-line string.

\$

${'$'}

f""

\"

exampleString.toInt() !: -1

I am writing a DSL that allows to parse HTML in kotlin.
(example: <https://github.com/skrapeit/skrape.it#parse-and-verify-html-from-string>)    
since *  is common to use in this context (e.g. when it comes to css selectors) it would feel natural if the DSL could do as well. Therefore it would be handy if it would be possible to overload a unaryTimes operator.
since kotlin already supports unaryPlus and unaryMinus overload, why there isn't a unaryTimes?
here is an example what it looks like right now:

@Test
fun `can parse html from String`() {
    htmlDocument("""
        <html>
            <body>
                <h1>welcome</h1>
                <div>
                    <p>first p-element</p>
                    <p class="foo">some p-element</p>
                    <p class="foo">last p-element</p>
                </div>
            </body>
        </html>""") {
        h1 {
            findFirst {
                text toBe "welcome"
            }
            p {
                withClass = "foo"
                findSecond {
                    text toBe "some p-element"
                    className  toBe "foo"
                }
            }
            p {
                findAll {
                    text toContain "p-element"
                }
                findLast {
                    text toBe "last p-element"
                }
            }
        }
    }
}

i think this should be possible right now by making * an infix operator?

@Test
fun `can parse html from String`() {
    htmlDocument("""
    <html>
        <body>
            <h1>welcome</h1>
            <div>
                <p>first p-element</p>
                <p class="foo">some p-element</p>
                <p class="foo">last p-element</p>
            </div>
        </body>
    </html>""") {
        h1 {
            find 0 {
            text toBe "welcome"
        }
            p {
                withClass = "foo"
                find 1 {
                    text toBe "some p-element"
                    className  toBe "foo"
                }
            }
            p {
                find * {
                    text toContain "p-element"
                }
                findLast {
                    text toBe "last p-element"
                }
            }
        }
    }
}

what would be possible due to the proposal of having unaryTimes operator to overload:

@Test
fun `can parse html from String`() {
    htmlDocument("""
    <html>
        <body>
            <h1>welcome</h1>
            <div>
                <p>first p-element</p>
                <p class="foo">some p-element</p>
                <p class="foo">last p-element</p>
            </div>
        </body>
    </html>""") {
        h1 {
            0 { // already possible by invoke operator
                text toBe "welcome"
            }
            p {
                withClass = "foo"
                1 {
                    text toBe "some p-element"
                    className  toBe "foo"
                }
            }
            p {
                * { // would need unaryTimes
                text toContain "p-element"
            }
                findLast {
                    text toBe "last p-element"
                }
            }
        }
    }
}

T?

T!!

interface LoadingCache<K : Any, V> {
    fun get(key: K): V // <-- If it can return null then it must be specified by type V

    // If load returns null then entries are missing hence it doesnt make sense to have here : Map<K,V?>
    fun getAll(keys: Iterable<K>): Map<K, V!!> {
        return keys.mapNotNull { k -> get(k)?.let { k to it } }.toMap()
    }
}

abstract

NotImplementedError

interface FooRepository {
   fun add(foo: Foo)
   fun get(id: String): Foo?
   fun delete(id: String)
}

var actual: Foo? = null
val creator = FooCreator(repository = test object : FooRepository {
   override fun add(foo: Foo) {
      assertNull(actual)
      actual = foo
   }
})

creator.create(id = "bar")
assertEquals(actual, Foo(id = "bar"))