val va: (String, Int) -> String = { str, n ->
    str.repeat(n) + str.repeat(n)
}

// 확장 람다
// String 파라메터를 괄호 밖으로 옮겨서 String.(Int) 처럼 확장 함수 구문 사용
// 확장 대상 객체(여기서는 String) 이 수신 객체가 되고, this 를 통해서 수신 객체에 접근 가능
val vb: String.(Int) -> String = {
    this.repeat(it) + repeat(it)
}

fun main() {
    val result1 = va("Assu", 2)
    val result2 = "Assu".vb(2)
    val result3 = vb("Assu", 2)

    // 컴파일되지 않음
    // val result4 = "Assu".va(2)

    println(result1) // AssuAssuAssuAssu
    println(result2) // AssuAssuAssuAssu
    println(result3) // AssuAssuAssuAssu
}

// String 파라메터를 괄호 밖으로 옮겨서 String.(Int) 처럼 확장 함수 구문 사용
// 확장 대상 객체(여기서는 String) 이 수신 객체가 되고, this 를 통해서 수신 객체에 접근 가능
val vb: String.(Int) -> String = {
    this.repeat(it) + repeat(it)
}

// Int 의 확장 람다
// 파라메터는 아무것도 받지 않고 Boolean 리턴 () -> Boolean
val zero: Int.() -> Boolean = {
    this == 0
}

// 파라메터에 이름을 붙이는 대신 `it` 사용
val one: Int.(Int) -> Boolean = {
    this % it == 0
}

val two: Int.(Int, Int) -> Boolean = { arg1, arg2 ->
    this % (arg1 + arg2) == 0
}

val three: Int.(Int, Int, Int) -> Boolean = { arg1, arg2, arg3 ->
    this % (arg1 + arg2 + arg3) == 0
}

fun main() {
    val result1 = 0.zero()
    val result2 = 10.one(10)
    val result3 = 20.two(10, 10)
    val result4 = 30.three(10, 10, 10)

    println(result1) // true
    println(result2) // true
    println(result3) // true
    println(result4) // true
}

class A {
    fun af() = 1
}

class B {
    fun bf() = 2
}

fun f1(lambda1: (A, B) -> Int) = lambda1(A(), B())

// 함수의 파라메터로 확장 람다 사용
fun f2(lambda2: A.(B) -> Int) = A().lambda2(B())

fun main() {
    val result1 = f1 { aa, bb -> aa.af() + bb.bf() }
    val result2 = f2 { af() + it.bf() }

    println(result1) // 3
    println(result2) // 3
}

class A1 {
    fun af() = 1
}

fun unitReturn(lambda1: A1.() -> Unit) = A1().lambda1()

fun nonUnitReturn(lambda1: A.() -> String) = A().lambda1()

fun main() {
    val result1 = unitReturn { "Unit 은 리턴값을 무시하기 때문에 이건 아무것도 할 수 없음" }
    val result2 = unitReturn { 1 } // 임의의 타입
    val result3 = unitReturn { } // 아무 값도 만들어내지 않는 경우
    val result4 = nonUnitReturn { "적절한 타입을 넣어주세요" }

    // 컴파일 오류
    // val result5 = nonUnitReturn { }

    println(result1) // kotlin.Unit
    println(result2) // kotlin.Unit
    println(result3) // kotlin.Unit
    println(result4) // 적절한 타입을 넣어주세요
}

// 일반 람다를 파라메터로 받는 String 의 확장 함수
fun String.transform1(
    n: Int,
    lambda: (String, Int) -> String,
) = lambda(this, n)

// 확장 람다를 파라메터로 받는 String 의 확장 함수
fun String.transform2(
    n: Int,
    lambda: String.(Int) -> String,
) = lambda(this, n)

// val 를 선언하여 String 의 확장 람다 이용
val duplicate: String.(Int) -> String = { repeat(it) }

// val 를 선언하여 String 의 확장 람다 이용
val alternate: String.(Int) -> String = {
    toCharArray()
        .filterIndexed { i, _ -> i % it == 0 }
        .joinToString(separator = "")
}

fun main() {
    val result1 = "hello".transform1(5, duplicate).transform2(3, alternate)
    val result2 = "hello".transform2(5, duplicate).transform1(3, alternate)

    println(result1) // hleolhleo
    println(result2) // hleolhleo
}

inline fun <T> Array<out T>.filterIndexed(predicate: (index: Int, T) -> Boolean): List<T>

fun Int.d1(f: (Int) -> Int) = f(this) * 10

fun Int.d2(f: Int.() -> Int) = f(this) * 10

fun f1(n: Int) = n + 3

fun Int.f2() = this + 3

fun main() {
    val result1 = 11.d1(::f1)
    val result2 = 11.d2(::f1)
    val result3 = 11.d1(Int::f2)
    val result4 = 11.d2(Int::f2)

    println(result1) // 140
    println(result2) // 140
    println(result3) // 140
    println(result4) // 140
}

open class Base {
    open fun f() = 1
}

class Derived : Base() {
    override fun f() = 2
}

// 일반 확장 함수
fun Base.g() = f()

// 확장 람다
fun Base.h(x: Base.() -> Int) = x()

fun main() {
    val b: Base = Derived() // 업캐스트

    val result1 = b.g()
    val result2 = b.h { f() }

    println(result1) // 2
    println(result2) // 2
}

fun exec(
    arg1: Int,
    arg2: Int,
    f: Int.(Int) -> Boolean,
) = arg1.f(arg2)

fun main() {
    val result =
        exec(
            10,
            2,
            fun Int.(d: Int): Boolean { // 익명 람다 위치에 익명 확장 함수를 사용
                println("---$this") // 10
                return this % d == 0
            },
        )

    println(result) // true
}

// StringBuilder 로 문자열 생성
private fun messy(): String {
    // StringBuilder 생성
    val built = StringBuilder()

    built.append("ABCs: ")

    // a~x 까지의 문자열을 덧붙임
    ('a'..'x').forEach { built.append(it) }

    // 결과 생성
    return built.toString()
}

// buildString() 으로 문자열 생성
// append() 호출의 수신 책게를 직접 만들고 관리할 필요가 없음
private fun clean(): String =
    buildString {
        append("ABCs: ")
        ('a'..'x').forEach { append(it) }
    }

// joinToString() 으로 문자열 생성
private fun cleaner(): String = ('a'..'x').joinToString(separator = "", prefix = "ABCs: ")

fun main() {
    val result1 = messy()
    val result2 = clean()
    val result3 = cleaner()

    // 모두 동일한 결과
    // ABCs: abcdefghijklmnopqrstuvwx
    println(result1)
    println(result2)
    println(result3)
}

val characters: List<String> =
    buildList {
        add("Chars: ")
        ('a'..'d').forEach { add("$it") }
    }

val charMap: Map<Char, Int> =
    buildMap {
        ('a'..'d').forEachIndexed { n, ch -> put(ch, n) }
    }

fun main() {
    println(characters) // [Chars: , a, b, c, d]
    println(charMap) // {a=0, b=1, c=2, d=3}
}

// ArrayList<RecipeUnit> 을 상속
open class Recipe : ArrayList<RecipeUnit>()

open class RecipeUnit {
    override fun toString() = "${this::class.simpleName}"
}

open class Operation : RecipeUnit()
class Toast : Operation()
class Grill : Operation()
class Cut : Operation()

open class Ingredient : RecipeUnit()
class Bread : Ingredient()
class Ham : Ingredient()
class Swiss : Ingredient()
class PeanutButter : Ingredient()
class Mustard : Ingredient()

open class Sandwich : Recipe() {
    fun action(op: Operation): Sandwich {
        add(op)
        return this
    }

    fun grill() = action(Grill())
    fun toast() = action(Toast())
    fun cut() = action(Cut())
}

// fillings 확장 람다는 호출자가 Sandwich 를 여러 가지 설정으로 준비할 수 있도록 해줌
fun sandwich(fillings: Sandwich.() -> Unit): Sandwich {
    val sandwich = Sandwich()
    sandwich.add(Bread())
    sandwich.toast()
    sandwich.fillings()
    sandwich.cut()
    return sandwich
}

fun main() {
    val result1 =
        sandwich {
            add(Ham())
            add(Mustard())
        }

    val result2 =
        sandwich {
            add(Swiss())
            add(PeanutButter())
            grill()
        }

    println(result1)
    println(result2)
}

data class Tag(var n: Int = 0) {
  var s: String = ""

  fun incr() = ++n
}

fun main() {
  // let() 사용 (this 로 객체 접근 불가)
  // 객체를 it 으로 접근하고, 람다의 마지막 식의 값을 반환
  val result1 =
    Tag(1).let {
      it.s = "let: ${it.n}"
      it.incr()
    }

  // let() 을 사용하면서 람다 인자에 이름을 붙임
  val result2 =
    Tag(2).let { tag ->
      tag.s = "let: ${tag.n}"
      tag.incr()
    }

  // run() 사용 (it 으로 객체 접근 불가)
  // 객체를 this 로 접근하고, 람다의 마지막 식의 값을 반환
  val result3 =
    Tag(3).run {
      s = "run: $n" // 암시적 this
      incr()
    }

  // with() 사용 (it 으로 객체 접근 불가)
  // 객체를 this 로 접근하고, 람다의 마지막 식을 반환
  val result4 =
    with(Tag(4)) {
      s = "with: $n"
      incr()
    }

  // apply() 사용 (it 으로 객체 접근 불가)
  // 객체를 this 로 접근하고, 변경된 객체를 다시 반환
  val result5 =
    Tag(5).apply {
      s = "apply: $n"
      incr()
    }

  // also() 사용 (this 로 객체 접근 불가)
  // 객체를 it 으로 접근하고, 변경된 객체를 다시 반환
  val result6 =
    Tag(6).also {
      it.s = "also: $it.n"
      it.incr()
    }

  // also() 에서도 람다의 인자에 이름을 붙일 수 있음
  val result7 =
    Tag(7).also { tag ->
      tag.s = "also: $tag.n"
      tag.incr()
    }

  println(result1) // 2
  println(result2) // 3
  println(result3) // 4
  println(result4) // 5
  println(result5) // Tag(n=6)
  println(result6) // Tag(n=7)
  println(result7) // Tag(n=8)
}

import kotlin.random.Random

fun gets(): String? = if (Random.nextBoolean()) "str!" else null

fun main() {
    val result =
        gets()?.let {   // gets() 의 반환값이 null 이 아닐 때만 let 이 호출됨
            // let 에서 null 이 될 수 없는 수신 객체는 람다 내부에서 null 이 될 수 없는 it 이 됨
            it.removeSuffix("!") + it.length
        }

    println(result) // str4 or null
}

class Gnome(val name: String) {
    fun who() = "Gnome $name"
}

fun whatGnome(gnome: Gnome?) {
    gnome?.let { it.who() }
    gnome.let { it?.who() } // 영역 함수 안에서 개별적으로 null 검사

    gnome?.run { this.who() }
    gnome.run { this?.who() } // 영역 함수 안에서 개별적으로 null 검사

    gnome?.apply { who() }
    gnome.apply { this?.who() } // 영역 함수 안에서 개별적으로 null 검사

    gnome?.also { it.who() }
    gnome.also { it?.who() } // 영역 함수 안에서 개별적으로 null 검사

    // 문맥 객체인 gnome 이 null 인지 검사할 방법이 없음
    with(gnome) { this?.who() } // 영역 함수 안에서 개별적으로 null 검사
}

class Gnome1(val name: String) {
    fun who() = "Gnome $name"
}

fun whichGnome(gnome: Gnome1?) {
    println(gnome?.name)
    gnome?.let { println(it.who()) }
    gnome?.run { println(who()) }
    gnome?.apply { println(who()) }
    gnome?.also { println(it.who()) }
}

fun main() {
    // Assu
    // Gnome Assu
    // Gnome Assu
    // Gnome Assu
    // Gnome Assu
    whichGnome(Gnome1("Assu"))

    // null
    whichGnome(null)
}

data class Toy(var id: Int)

fun display(iMap: Map<String, Toy>) {
    println("display: $iMap")

    val toy1: Toy =
        iMap["main"]?.let {
            it.id += 10
            it
        } ?: return // map 의 key 에 main 이 없으면 display() 함수를 종료시키므로 아래 로직을 실행되지 않음
    println("toy1: $toy1")

    val toy2: Toy? =
        iMap["main"]?.run {
            id += 10
            this
        }
    println("toy2: $toy2")

    val toy3: Toy? =
        iMap["main"]?.apply {
            id += 10
            this // 변경된 객체를 다시 반환하므로 의미없는 구문
        }
    println("toy3: $toy3")

    val toy4: Toy? =
        iMap["main"]?.apply {
            id += 10
        }
    println("toy4: $toy4")

    val toy5: Toy? =
        iMap["main"]?.also {
            it.id += 10
        }
    println("toy5: $toy5")
}

fun main() {
    // display: {main=Toy(id=1)}
    // toy1: Toy(id=11)
    // toy2: Toy(id=21)
    // toy3: Toy(id=31)
    // toy4: Toy(id=41)
    // toy5: Toy(id=51)
    display(mapOf("main" to Toy(1)))

    // display: {none=Toy(id=1)}
    display(mapOf("none" to Toy(1)))
}

val functions =
    listOf(
        // 익명 함수
        fun(name: String?) {
            name
                ?.takeUnless { it.isBlank() } // name 이 빈 값이 아니면 name 리턴
                ?.let { println("$it in let()") }
        },
        fun(name: String?) {
            name
                ?.takeUnless { it.isBlank() }
                ?.run { println("$this in run()") }
        },
        fun(name: String?) {
            name
                ?.takeUnless { it.isBlank() }
                ?.apply { println("$this in apply()") }
        },
        fun(name: String?) {
            name
                ?.takeUnless { it.isBlank() }
                ?.also { println("$it in also()") }
        },
    )

fun main() {
    // 아무것도 출력되지 않음
    functions.forEach { it(null) }

    // 아무것도 출력되지 않음
    functions.forEach { it(" ") }

    // AHAHAHA in let()
    // AHAHAHA in run()
    // AHAHAHA in apply()
    // AHAHAHA in also()
    functions.forEach { it("AHAHAHA") }
}

public inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T? {
    return if (!predicate(this)) this else null
}

// AutoCloseable 인터페이스 구현
data class Blob(val id: Int) : AutoCloseable {
    override fun toString() = "Blob($id)"

    override fun close() = println("Close $this")

    fun show() = println("$this")
}

fun main() {
    Blob(1).let { it.show() } // Blob(1)
    Blob(2).run { show() } // Blob(2)
    with(Blob(3)) { show() } // Blob(3)
    Blob(4).apply { show() } // Blob(4)
    Blob(5).also { it.show() } // Blob(5)

    // Blob(6)
    // Close Blob(6)
    Blob(6).use { it.show() }

    // 영역 함수를 사용하면서 자원 해제를 보장하고 싶다면 영역 함수를 use() 람다 안에 사용해야 함
    // Blob(7)
    // Close Blob(7)
    Blob(7).use { it.run { show() } }

    // 명시적으로 close() 호출
    // Blob(8)
    // Close Blob(8)
    Blob(8).apply { show() }.also { it.close() }

    // 명시적으로 close() 호출
    // Blob(9)
    // Close Blob(9)
    Blob(9).also { it.show() }.apply { close() }

    // apply() 를 사용하고 그 결과를 use() 에 전달
    // 결과를 전달받은 use() 를 람다가 끝날 때 close() 호출
    // Blob(10)
    // Close Blob(10)
    Blob(10).apply { show() }.use {}
}