R

kotlin.function

fun a(R) {
    R.invoke()
}

kotlin.Function
kotlin.Function(R) is the unified supertype of all function types. It is parame-
terized over function return type R.

fun a(r: () -> Unit) {
   r()
}

R

<T, R> T.let(block: (T) -> R): R

T

String?

Stack<String>?

/**
 * converts a [String] into a [Stack]
 * @see Stack.toStringConcat
 * @return the resulting conversion
 */
fun String.toStack(): Stack<String> {
    val deq = Stack<String>()
    var i = 0
    while (i < this.length) deq.addLast(this[i++].toString())
    return deq
}

/**
 * converts a [String] into a [Stack]
 * @see Stack.toStringConcat
 * @return the resulting conversion
 */
fun String?.toStack(): Stack<String>? { 
    if (this == null) return null
    return this.toStack()
}

val a: String = "a"
val b: String? = "a"
a.toStack()
b.toStack()

String?.toStack

String

Type mismatch: inferred type is Stack<String>? but Stack<String> was expected

R

T

as T

T

R

let

R

In the code above, the parameter combine has a function type (R, T) -> R, so it accepts a function that takes two arguments of types R and T and returns a value of type R. It is invoked inside the for-loop, and the return value is then assigned to accumulator.

let

fun <T> retz(n:T): T {
    return n as T // valid as it returns the input of whatever it is given
}

fun <T> retz(): T {
    return 0 as T // this is invalid
}

fun a() {
    val x = retz<Int>()
    var y : Int = retz(0)
}

y

x

fun <T> T.retz(): T {
    return this // returns itself
}

fun b() {
    var x = 5
    x = x.retz()
}

R

R

this

T

R

R

val pair: Pair<Int, String> = createPair(1, "A")

T, T

A

B

fun <T> createPair(a: T, b: T): Pair<T, T> {
   return Pair(a, b)
}

let

String

it` will get passed the return value?

it

true

false

(0 is Int)

as inferred by the return value? or as specified by the return type?

"some".let {} // R to Unit
"some".let { it } // R to String
"42".let { it.toInt() } // R to Int

Block()

fun x() {
    val x = "a"
    val y = x.ifTrue(x.startsWith('a')) {
        it.get(0)
    }
    println("y = $y")
}

Type inference failed: Cannot infer type parameter T in fun  T.ifTrue(i: Boolean, Block: (ii: T) -> T): Boolean None of the following substitutions receiver: Comparable*> arguments: (Boolean,(Comparable*>) -> Comparable*>) receiver: String arguments: (Boolean,(String) -> String) can be applied to receiver: String arguments: (Boolean,(String) -> Char)

fun <T> T.ifTrue(i:Boolean, Block: (ii:T) -> T): Boolean {
    if (i) {
        Block(this)
    }
    return i
}

fun x() {
    val x = "a"
    val y = x.ifTrue(x.startsWith('a')) {
        it.get(0)
    }
    println("y = $y")
}

fun <T> T.ifTrue(i:Boolean, Block: (ii:T) -> T): T {
    if (i) {
        return Block(this)
    }
    return this
}

fun x() {
    val x = "a"
    val y = x.ifTrue(x.startsWith('a')) {
        it.length.toString()
    }
    println("y = $y")
}

it.length.toString()

also

let

if (x.startsWith('a')) {
        x.length.toString()
    } else {
        x
    }

if (x.startsWith('a')) x.length.toString() else x

val yx = x.ifTrueReturn(x.startsWith('a')) {
        x = it.drop(1)
    }

Expected a value of type String

x = it.drop(1)

x.also {
        x = it.drop(1)
    }

also

Block2: (T) -> Unit

@file:Suppress("unused")
fun <T> T.ifTrue(i:Boolean, Block: (ii:T) -> T): T {
    if (i) {
        return Block(this)
    }
    return this
}

fun <T> T.ifTrueReturn(ii:Boolean, Block2: (T) -> Unit): Boolean {
    if (ii) {
        Block2(this as T)
    }
    return ii
}

fun main() {
    var x = "abc"
    println("x = $x") // x = abc
    var y = x.ifTrue(x.startsWith('a')) {
        it.length.toString()
    }
    println("y = $y") // y = 3
    println("x = $x") // x = abc
    val yx = x.ifTrueReturn(x.startsWith('a')) {
        x = it.drop(1)
    }
    println("yx = $yx") // yx = true
    println("x = $x") // x = abc // should be "bc"
}

i want “it” to modify “x” itself

fun <T> T.ifTrueReturn(ii:Boolean, Block2: (T) -> Unit): Boolean {
    if (ii) Block2(this)
    return ii
}

fun <T> T.ifUnconditionalReturn(ii:Boolean, Block2: (T) -> Unit): Boolean {
    Block2(this)
    return ii
}

it.alias != null -> when {
    ifUnconditionalReturn(it.alias.equals(command) && !it.command.equals(command)) {
        println("alias found")
    }
        .ifTrueReturn { println("and it matches $command") }
        .ifFalseReturn { println("and it does not match $command") } -> {
        val t = get(it.command!!)
        if (t != null) return t
    }
}