蓝色的笔记本

interface RemoteApi {
    @GET("timeline")
    suspend fun timeline(): RemoteLaunchesResponse 
}

val client = OkHttpClient.Builder()
             .addInterceptor(loggingInterceptor)
             .build()

 val retrofit = Retrofit.Builder()
             .client(client)
             .baseUrl("http://10.0.0.2:8080/")
             .addConverterFactory(GsonConverterFactory.create())
             .build()

 val api = retrofit.create(RemoteApi::class.java) //1、create做了什么？

api.timeline() //2、调用接口方法怎么发起请求?

while (true) {
    select<Unit> {                                   
        references.onReceive { ref ->                // (1)
            val loc = ref.resolveLocation()
            ... 
            locations.send(loc)                      // (2)
        }
        contents.onReceive { (loc, content) -> ... } // (3)
    }
}

for (loc in locations) {                             // (4)
    val content = downloadContent(loc)         
    contents.send(LocContent(loc, content))          // (5)
}

for (msg in mailbox) {
    when (msg) {
        is Reference -> ...
        is LocContent -> ...
    }
}

select<Unit> {
    contents.onReceive { ... }
    references.onReceive { 
        ... 
        locations.send(loc)                      // (2)
    }
}

val contents = Channel<LocContent>(1)

body {
    div {
        a("https://kotlinlang.org") {
            target = ATarget.blank
            +"Main site"
        }
    }
    +"Some content"
}

verticalLayout {
    val name = editText()
    button("Say Hello") {
        onClick { toast("Hello, ${name.text}!") }
    }
}

class HelloWorld : View() {
    override val root = hbox {
        label("Hello world") {
            addClass(heading)
        }

        textfield {
            promptText = "Enter your name"
        }
    }
}

fun Routing.api() {
    route("news") {
        get {
            val newsData = NewsUseCase.getAcceptedNews()
            call.respond(newsData)
        }
        get("propositions") {
            requireSecret()
            val newsData = NewsUseCase.getPropositions()
            call.respond(newsData)
        }
    }
    // ...
}

class MyTests : StringSpec({
    "length should return size of string" {
        "hello".length shouldBe 5
    }
    "startsWith should test for a prefix" {
        "world" should startWith("wor")
    }
})

plugins {
    `java-library`
}

dependencies {
    api("junit:junit:4.12")
    implementation("junit:junit:4.12")
    testImplementation("junit:junit:4.12")
}

configurations {
    implementation {
        resolutionStrategy.failOnVersionConflict()
    }
}

sourceSets {
    main {
        java.srcDir("src/core/java")
    }
}

java {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11
}

tasks {
    test {
        testLogging.showExceptions = true
    }
}

inline fun <T> Iterable<T>.filter(
    predicate: (T) -> Boolean
): List<T> {
    val list = arrayListOf<T>()
    for (elem in this) {
        if (predicate(elem)) {
            list.add(elem)
        }
    }
    return list
}

fun plus(a: Int, b: Int) = a + b

val plus1: (Int, Int) -> Int = { a, b -> a + b }
val plus2: (Int, Int) -> Int = fun(a, b) = a + b
val plus3: (Int, Int) -> Int = ::plus

val plus4 = { a: Int, b: Int -> a + b }
val plus5 = fun(a: Int, b: Int) = a + b

fun Int.myPlus(other: Int) = this + other

fun Int.myPlus(other: Int) = this + other

val myPlus: Int.(Int) -> Int =
    fun Int.(other: Int) = this + other

val myPlus: Int.(Int)->Int = { this + it }

myPlus.invoke(1, 2)
myPlus(1, 2)
1.myPlus(2)

class Dialog {
    var title: String = ""
    var text: String = ""
    fun show() { /*...*/ }
}

fun main() {
    val dialog = Dialog()
    dialog.title = "My dialog"
    dialog.text = "Some text"
    dialog.show()
}

class Dialog {
    var title: String = ""
    var text: String = ""
    fun show() { /*...*/ }
}

fun main() {
    val dialog = Dialog()
    val init: Dialog.() -> Unit = {
        title = "My dialog"
        text = "Some text"
    }
    init.invoke(dialog)
    dialog.show()
}

class Dialog {
    var title: String = ""
    var text: String = ""
    fun show() { /*...*/ }
}

fun showDialog(init: Dialog.() -> Unit) {
    val dialog = Dialog()
    init.invoke(dialog)
    dialog.show()
}

fun main() {
    showDialog {
        title = "My dialog"
        text = "Some text"
    }
}

inline fun <T> T.apply(block: T.() -> Unit): T {
    this.block()
    return this
}

Dialog().apply {
    title = "My dialog"
    text = "Some text"
}.show()

fun createTable(): TableBuilder = table {
    tr {
        for (i in 1..2) {
            td {
                +"This is column $i"
            }
        }
    }
}

fun table(init: TableBuilder.()->Unit): TableBuilder {
    //...
}

class TableBuilder {
    fun tr(init: TrBuilder.() -> Unit) { /*...*/ }
}

class TrBuilder {
    fun td(init: TdBuilder.()->Unit) { /*...*/ }
}

class TdBuilder {
    var text = ""

    operator fun String.unaryPlus() {
        text += this
    }
}

fun table(init: TableBuilder.()->Unit): TableBuilder {
    val tableBuilder = TableBuilder()
    init.invoke(tableBuilder)
    return tableBuilder
}

fun table(init: TableBuilder.()->Unit) =
    TableBuilder().apply(init)

class TableBuilder {
    var trs = listOf<TrBuilder>()

    fun tr(init: TrBuilder.()->Unit) {
        trs = trs + TrBuilder().apply(init)
    }
}

class TrBuilder {
    var tds = listOf<TdBuilder>()

    fun td(init: TdBuilder.()->Unit) {
        tds = tds + TdBuilder().apply(init)
    }
}

operator fun <T> Iterable<T>.plus(element: T): List<T> {
    if (this is Collection) return this.plus(element)
    val result = ArrayList<T>()
    result.addAll(this)
    result.add(element)
    return result
}

inline fun <T, R> Iterable<T>.map(
    transform: (T) -> R
): List<R> {
    val size =
        if (this is Collection<*>) this.size else 10
    val destination = ArrayList<R>(size)
    for (item in this)
        destination.add(transform(item))
    return destination
}

// This is not how map is implemented
inline fun <T, R> Iterable<T>.map(
    transform: (T) -> R
): List<R> {
    var destination = listOf<R>()
    for (item in this)
        destination += transform(item)
    return destination
}

public inline fun repeat(times: Int, action: (Int) -> Unit) {
    for (index in 0 until times) {
        action(index)
    }
}

public inline fun <T, R> Iterable<T>.map(
    transform: (T) -> R
): List<R> {
    return mapTo(
        ArrayList<R>(collectionSizeOrDefault(10)),
        transform
    )
}

public inline fun <T> Iterable<T>.filter(
    predicate: (T) -> Boolean
): List<T> {
    return filterTo(ArrayList<T>(), predicate)
}

repeat(10) {
    print(it)
}
//↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓
for (index in 0 until 10) {
    print(index)
}

any is List<Int> // Error
any is List<*> // OK

fun <T> printTypeName() {
    print(T::class.simpleName) // ERROR
}

inline fun <reified T> printTypeName() {
    print(T::class.simpleName)
}

// Usage
printTypeName<Int>()    //→print(Int::class.simpleName) // Int
printTypeName<Char>()   //→print(Char::class.simpleName)// Char
printTypeName<String>() //→print(String::class.simpleName)// String

class Worker
class Manager

val employees: List<Any> =
    listOf(Worker(), Manager(), Worker())

val workers: List<Worker> =
    employees.filterIsInstance<Worker>()

inline fun <reified T : Any> String.fromJsonOrNull(): T? =
    try {
        gson.fromJson(json, T::class.java)
    } catch (e: JsonSyntaxException) {
        null
    }

// usage
val user: User? = userAsText.fromJsonOrNull()

// Koin module declaration
val myModule = module {
    single { Controller(get()) } // get is reified
    single { BusinessService() } // get is reified
}

// Koin injection
val service: BusinessService by inject()
// inject is reified

inline fun print(message: Any?) {
    System.out.print(message)
}

val lambda: () -> Unit = {
    // code
}

class OnClickListener : () -> Unit {
    override fun invoke() {
        // ...
    }
}

inline fun repeat(times: Int, action: (Int) -> Unit) {
    for (index in 0 until times) {
        action(index)
    }
}

fun repeatNoinline(times: Int, action: (Int) -> Unit) {
    for (index in 0 until times) {
        action(index)
    }
}

@Benchmark
fun nothingInline(blackhole: Blackhole) {
    repeat(100_000_000) {
        blackhole.consume(it)
    }
}

@Benchmark
fun nothingNoninline(blackhole: Blackhole) {
    noinlineRepeat(100_000_000) {
        blackhole.consume(it)
    }
}

users.filter { it.bought }.sumByDouble { it.price }

var l = 1L
noinlineRepeat(100_000_000) {
    l += it
}

val a = Ref.LongRef()
a.element = 1L
noinlineRepeat(100_000_000) {
    a.element = a.element + it
}

@Benchmark
// On average 30 ms
fun nothingInline(blackhole: Blackhole) {
    var l = 0L
    repeat(100_000_000) {
        l += it
    }
    blackhole.consume(l)
}

@Benchmark
// On average 274 ms
fun nothingNoninline(blackhole: Blackhole) {
    var l = 0L
    noinlineRepeat(100_000_000) {
        l += it
    }
    blackhole.consume(l)
}

if (value != null) {
    print(value)
}

for (i in 1..10) {
    print(i)
}

repeatNoninline(10) {
    print(it)
}

fun main() {
    repeatNoinline(10) {
        print(it)
        return // ERROR: Not allowed
    }
}

fun main() {
    repeat(10) {
        print(it)
        return // OK
    }
}

fun getSomeMoney(): Money? {
    repeat(100) {
        val money = searchForMoney()
        if (money != null) return money
    }
    return null
}

inline fun a() {
    b()
}
inline fun b() {
    c()
}
inline fun c() {
    a()
}

internal inline fun read() {
    val reader = Reader() // Error
    // ...
}

private class Reader {
    // ...
}

inline fun printThree() {
    print(3)
}

inline fun threePrintThree() {
    printThree()
    printThree()
    printThree()
}

inline fun threeThreePrintThree() {
    threePrintThree()
    threePrintThree()
    threePrintThree()
}

inline fun threeThreeThreePrintThree() {
    threeThreePrintThree()
    threeThreePrintThree()
    threeThreePrintThree()
}

inline fun printThree() {
    print(3)
}

inline fun threePrintThree() {
    print(3)
    print(3)
    print(3)
}

inline fun threeThreePrintThree() {
    print(3)
    print(3)
    print(3)
    print(3)
    print(3)
    print(3)
    print(3)
    print(3)
    print(3)
}

inline fun threeThreeThreePrintThree() {
    print(3)
    print(3)
    print(3)    
 ...
    print(3)
    print(3)
    print(3)
    print(3)
}

inline fun hello(postAction:()->Unit){
    println("Hello")
    runOnUiThread { 
        postAction()
     }
}

inline fun requestNewToken(
    hasToken: Boolean,
    crossinline onRefresh: () -> Unit,
    noinline onGenerate: () -> Unit
) {
    if (hasToken) {
        httpCall("get-token", onGenerate) // We must use 
        // noinline to pass function as an argument to a
        // function that is not inlined
    } else {
        httpCall("refresh-token") {
            onRefresh() // We must use crossinline to 
            // inline function in a context where 
            // non-local return is not allowed
            onGenerate()
        }
    }
}

fun httpCall(url: String, callback: () -> Unit) {
    /*...*/
}

interface Iterable<out T> {
    operator fun iterator(): Iterator<T>
}

interface Sequence<out T> {
    operator fun iterator(): Iterator<T>
}

public inline fun <T> Iterable<T>.filter(
    predicate: (T) -> Boolean
): List<T> {
    return filterTo(ArrayList<T>(), predicate)
}

public fun <T> Sequence<T>.filter(
    predicate: (T) -> Boolean
): Sequence<T> {
    return FilteringSequence(this, true, predicate)
}

val seq = sequenceOf(1, 2, 3)
val filtered = seq.filter { print("f$it "); it % 2 == 1 }
println(filtered)  // FilteringSequence@...

val asList = filtered.toList()
// f1 f2 f3
println(asList) // [1, 3]

val list = listOf(1, 2, 3)
val listFiltered = list
    .filter { print("f$it "); it % 2 == 1 }
// f1 f2 f3
println(listFiltered) // [1, 3]

for (e in listOf(1, 2, 3)) {
    print("F$e, ")
    if (e % 2 == 1) {
        print("M$e, ")
        val mapped = e * 2
        print("E$mapped, ")
    }
}
// Prints: F1, M1, E2, F2, F3, M3, E6,

generateSequence(1) { it + 1 }
    .map { it * 2 }
    .take(10)
    .forEach { print("$it, ") }
// Prints: 2, 4, 6, 8, 10, 12, 14, 16, 18, 20,

import java.math.BigDecimal

val fibonacci: Sequence<BigDecimal> = sequence {
    var current = 1.toBigDecimal()
    var prev = 1.toBigDecimal()
    yield(prev)
    while (true) {
        yield(current)
        val temp = prev
        prev = current
        current += temp
    }
}

fun main() {
    print(fibonacci.take(10).toList())
    // [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
}

print(fibonacci.toList()) // Runs forever

// BAD SOLUTION, DO NOT USE COLLECTIONS FOR 
// POSSIBLY BIG FILES
File("ChicagoCrimes.csv")
    .readLines()
    .drop(1) // Drop descriptions of the columns
    .mapNotNull { it.split(",").getOrNull(6) }
    // Find description
    .filter { "CANNABIS" in it }
    .count()
    .let(::println)

File("ChicagoCrimes.csv").useLines { lines ->
// The type of `lines` is Sequence<String>
    lines.drop(1) // Drop descriptions of the columns
        .mapNotNull { it.split(",").getOrNull(6) }
        // Find description
        .filter { "CANNABIS" in it }
        .count()
        .let { println(it) } // 318185
}

fun singleStepListProcessing(): List<Product> {
    return productsList.filter { it.bought }
}

fun singleStepSequenceProcessing(): List<Product> {
    return productsList.asSequence()
        .filter { it.bought }
        .toList()
}

fun twoStepListProcessing(): List<Double> {
    return productsList
        .filter { it.bought }
        .map { it.price }
}

fun twoStepSequenceProcessing(): List<Double> {
    return productsList.asSequence()
        .filter { it.bought }
        .map { it.price }
        .toList()
}

fun threeStepListProcessing(): Double {
    return productsList
        .filter { it.bought }
        .map { it.price }
        .average()
}

fun threeStepSequenceProcessing(): Double {
    return productsList.asSequence()
        .filter { it.bought }
        .map { it.price }
        .average()
}

generateSequence(0) { it + 1 }.take(10).sorted().toList()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
generateSequence(0) { it + 1 }.sorted().take(10).toList()
// Infinite time. Does not return.

productsList.asSequence()
    .filter { it.bought }
    .map { it.price }
    .sorted()
    .take(10)
    .sum()

//结点定义
class Tree(val left: Tree?, val right: Tree?)

//构造二叉树：以叶子结点开始，重复构造父结点，并把当前结点作为父结点的左子树
val n = 100_000
val deepTree = generateSequence(Tree(null, null)) { prev ->
    Tree(prev, null) 
}.take(n).last()

fun depth(t: Tree?): Int =
    if (t == null) 0 else maxOf(
        depth(t.left), // recursive call one
        depth(t.right) // recursive call two
    ) + 1

fun depth(t: Tree?): Int {
      if (t == null) return 0
      class Frame(val node: Tree, var state: Int = 0, var depth: Int = 1)
      val stack = ArrayList<Frame>()
      val root = Frame(t)
      stack.add(root)
      while (stack.isNotEmpty()) {
          val frame = stack.last()
          when (frame.state++) {
              0 -> frame.node.left?.let { l -> stack.add(Frame(l)) }
              1 -> frame.node.right?.let { r -> stack.add(Frame(r)) }
              2 -> {
                  stack.removeLast()
                  stack.lastOrNull()?.let { p -> 
                      p.depth = maxOf(p.depth, frame.depth + 1) 
                  }
              }
          }
      }
      return root.depth
  }

val depth = DeepRecursiveFunction<Tree?, Int> { t ->
        if (t == null) 0 else maxOf(
            callRecursive(t.left),
            callRecursive(t.right)
        ) + 1
    }

@SinceKotlin("1.4")
@ExperimentalStdlibApi
public operator fun <T, R> DeepRecursiveFunction<T, R>.invoke(value: T): R =
    DeepRecursiveScopeImpl<T, R>(block, value).runCallLoop()

@Suppress("UNCHECKED_CAST")
   fun runCallLoop(): R {
       while (true) {
           // Note: cont is set to null in DeepRecursiveScopeImpl.resumeWith when the whole computation completes
           val result = this.result
           val cont = this.cont
               ?: return (result as Result<R>).getOrThrow() // done -- final result
           // The order of comparison is important here for that case of rogue class with broken equals
           if (UNDEFINED_RESULT == result) {
               // call "function" with "value" using "cont" as completion
               val r = try {
                   // This is block.startCoroutine(this, value, cont)
                   function.startCoroutineUninterceptedOrReturn(this, value, cont)
               } catch (e: Throwable) {
                   cont.resumeWithException(e)
                   continue
               }
               // If the function returns without suspension -- calls its continuation immediately
               if (r !== COROUTINE_SUSPENDED)
                   cont.resume(r as R)
           } else {
               // we returned from a crossFunctionCompletion trampoline -- call resume here
               this.result = UNDEFINED_RESULT // reset result back
               cont.resumeWith(result)
           }
       }
   }

suspend fun callRecursive(value: T): R = 
    suspendCoroutineUninterceptedOrReturn { cont ->
        this.cont = cont
        this.value = value
        COROUTINE_SUSPENDED
    }