data class Customer(val name: String, val email: String)

fun foo(a: Int = 0, b: String = "") { ... }

val positives = list.filter { x -> x > 0 }
val positives = list.filter { it > 0 } // 更简洁

if ("john@example.com" in emailsList) { ... }
if ("jane@example.com" !in emailsList) { ... }

println("Name $name")

val wrongInt = readln().toIntOrNull()  // 如果输入无法转换为整数，则返回 null
val correctInt = readln().toIntOrNull() // 如果输入可以转换为整数，则返回整数

when (x) {
    is Foo -> ...
    is Bar -> ...
    else   -> ...
}

val list = listOf("a", "b", "c")

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

println(map["key"])
map["key"] = value  // 对于可变映射

for ((k, v) in map) {
    println("$k -> $v")
}

for (i in 1..100) { ... }  // 闭区间：包括 100
for (i in 1..<100) { ... } // 开区间：不包括 100
for (x in 2..10 step 2) { ... } // 步长为 2
for (x in 10 downTo 1) { ... } // 倒序
(1..10).forEach { ... } // 使用 forEach

val p: String by lazy { // 仅在第一次访问时计算该值
    // 计算字符串
}

fun String.spaceToCamelCase() { ... }

"Convert this to camelcase".spaceToCamelCase()

object Resource {
    val name = "Name"
}

@JvmInline
value class EmployeeId(private val id: String)

@JvmInline
value class CustomerId(private val id: String)

abstract class MyAbstractClass {
    abstract fun doSomething()
    abstract fun sleep()
}

fun main() {
    val myObject = object : MyAbstractClass() {
        override fun doSomething() {
            // ...
        }

        override fun sleep() { // ...
        }
    }
    myObject.doSomething()
}

val files = File("Test").listFiles()

println(files?.size) // 如果 files 不为空，则打印 size

val files = File("Test").listFiles()

println(files?.size ?: "empty") // 如果 files 为 null，则打印 "empty"

val filesSize = files?.size ?: run {
    val someSize = getSomeSize()
    someSize * 2
}
println(filesSize)

val values = ...
val email = values["email"] ?: throw IllegalStateException("Email is missing!")

val emails = ... // 可能为空
val mainEmail = emails.firstOrNull() ?: ""

val value = ...

value?.let {
    ... // 如果 value 不为空，则执行此代码块
}

val value = ...

val mapped = value?.let { transformValue(it) } ?: defaultValue
// 如果 value 或 transform 结果为空，则返回 defaultValue。

fun transform(color: String): Int {
    return when (color) {
        "Red" -> 0
        "Green" -> 1
        "Blue" -> 2
        else -> throw IllegalArgumentException("Invalid color param value")
    }
}

fun test() {
    val result = try {
        count()
    } catch (e: ArithmeticException) {
        throw IllegalStateException(e)
    }

    // 使用 result
}

val y = if (x == 1) {
    "one"
} else if (x == 2) {
    "two"
} else {
    "other"
}

fun arrayOfMinusOnes(size: Int): IntArray {
    return IntArray(size).apply { fill(-1) }
}

fun theAnswer() = 42

// 等价于

fun theAnswer(): Int {
    return 42
}

fun transform(color: String): Int = when (color) {
    "Red" -> 0
    "Green" -> 1
    "Blue" -> 2
    else -> throw IllegalArgumentException("Invalid color param value")
}

class Turtle {
    fun penDown()
    fun penUp()
    fun turn(degrees: Double)
    fun forward(pixels: Double)
}

val myTurtle = Turtle()
with(myTurtle) { // 画一个 100 像素的正方形
    penDown()
    for (i in 1..4) {
        forward(100.0)
        turn(90.0)
    }
    penUp()
}

val myRectangle = Rectangle().apply {
    length = 4
    breadth = 5
    color = 0xFAFAFA
}

val stream = Files.newInputStream(Paths.get("/some/file.txt"))
stream.buffered().reader().use { reader ->
    println(reader.readText())
}

inline fun <reified T: Any> Gson.fromJson(json: JsonElement): T = this.fromJson(json, T::class.java)

var a = 1
var b = 2
a = b.also { b = a }

val age: Int = 30
val name = "Alice"  // 类型推断为 String
val pi = 3.14        // 类型推断为 Double

val max = if (a > b) a else b  // 返回 a 或 b 中较大的值

when (x) {
    1 -> println("x is 1")
    in 2..5 -> println("x is between 2 and 5")
    is String -> println("x is a String")
    else -> println("x is something else")
}

val numbers = listOf(1, 2, 3)
for (number in numbers) {
    println(number)
}

for (i in 1..5) { // 1 到 5 (包含 5)
    println(i)
}

var count = 0
while (count < 5) {
    println("Count: $count")
    count++
}

var input: String
do {
    print("Enter a number (or 'q' to quit): ")
    input = readLine() ?: "" // 安全处理空输入
} while (input != "q")

for (i in 1..10) {
    if (i == 3) continue // 跳过 i=3 的迭代
    if (i == 7) break    // 循环在 i=7 时终止
    println(i)
}

loop@ for (i in 1..100) {
    for (j in 1..100) {
        if (...) break@loop // 退出标记为 loop 的循环
    }
}

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach lit@{
        if (it == 3) return@lit // 局部返回到 forEach 循环的调用者
        print(it)
    }
    print(" done with explicit label")
}
 

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return@forEach // 局部返回到 forEach 循环的调用者
        print(it)
    }
    print(" done with implicit label")
}
 

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach(fun(value: Int) {
        if (value == 3) return  // 局部返回到匿名函数的调用者
        print(value)
    })
    print(" done with anonymous function")
}
 

fun foo() {
    run loop@{
        listOf(1, 2, 3, 4, 5).forEach {
            if (it == 3) return@loop // 从传递给 run 的 lambda 表达式非局部返回
            print(it)
        }
    }
    print(" done with nested loop")
}

class Example // 隐式继承自 Any

open class Base // 类可以被继承

open class Base(p: Int)

class Derived(p: Int) : Base(p)

class MyView : View {
    constructor(ctx: Context) : super(ctx)

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
}

open class Shape {
    open fun draw() { /*...*/ }
    fun fill() { /*...*/ }
}

class Circle() : Shape() {
    override fun draw() { /*...*/ }
}

open class Rectangle() : Shape() {
    final override fun draw() { /*...*/ }
}

open class Shape {
    open val vertexCount: Int = 0
}

class Rectangle : Shape() {
    override val vertexCount = 4
}

interface Shape {
    val vertexCount: Int
}

class Rectangle(override val vertexCount: Int = 4) : Shape // 始终有 4 个顶点

class Polygon : Shape {
    override var vertexCount: Int = 0  // 稍后可以设置为任何数字
}

open class Base(val name: String) {

    init { println("Initializing a base class") }

    open val size: Int =
        name.length.also { println("Initializing size in the base class: $it") }
}

class Derived(
    name: String,
    val lastName: String,
) : Base(name.replaceFirstChar { it.uppercase() }.also { println("Argument for the base class: $it") }) {

    init { println("Initializing a derived class") }

    override val size: Int =
        (super.size + lastName.length).also { println("Initializing size in the derived class: $it") }
}

open class Rectangle {
    open fun draw() { println("Drawing a rectangle") }
    val borderColor: String get() = "black"
}

class FilledRectangle : Rectangle() {
    override fun draw() {
        super.draw()
        println("Filling the rectangle")
    }

    val fillColor: String get() = super.borderColor
}

class FilledRectangle: Rectangle() {
    override fun draw() {
        val filler = Filler()
        filler.drawAndFill()
    }

    inner class Filler {
        fun fill() { println("Filling") }
        fun drawAndFill() {
            super@FilledRectangle.draw() // 调用 Rectangle.draw()
            fill()
            println("Drawn a filled rectangle with color ${super@FilledRectangle.borderColor}") // 使用 Rectangle 的 borderColor 的 get() 实现
        }
    }
}

open class Rectangle {
    open fun draw() { /* ... */ }
}

interface Polygon {
    fun draw() { /* ... */ } // 接口成员默认是 'open' 的
}

class Square() : Rectangle(), Polygon {
    // 编译器要求重写 draw()：
    override fun draw() {
        super<Rectangle>.draw() // 调用 Rectangle.draw()
        super<Polygon>.draw() // 调用 Polygon.draw()
    }
}

class Box<T>(t: T) {
    var value = t
}

val box: Box<Int> = Box<Int>(1) // 显式指定类型
val box = Box(1) // 编译器推断类型为 Box<Int>

interface Source<out T> {
    fun nextT(): T
}

fun demo(strs: Source<String>) {
    val objects: Source<Any> = strs // This is OK, since T is an out-parameter
    // ...
}

interface Comparable<in T> {
    operator fun compareTo(other: T): Int
}

fun demo(x: Comparable<Number>) {
    x.compareTo(1.0) // 1.0 has type Double, which is a subtype of Number
    // Thus, you can assign x to a variable of type Comparable<Double>
    val y: Comparable<Double> = x // OK!
}

fun copy(from: Array<out Any>, to: Array<Any>) { ... } // 禁止写入 from
fun fill(dest: Array<in String>, value: String) { ... } // 禁止读取 dest

fun <T> singletonList(item: T): List<T> { ... }
fun <T> T.basicToString(): String { ... } // 扩展函数

val l = singletonList<Int>(1) // 显式指定类型
val l = singletonList(1) // 编译器推断类型

fun <T : Comparable<T>> sort(list: List<T>) { ... } // T 必须是 Comparable<T> 的子类型

fun <T> copyWhenGreater(list: List<T>, threshold: T): List<String>
    where T : CharSequence,
          T : Comparable<T> {
    return list.filter { it > threshold }.map { it.toString() }
} // T 必须同时实现 CharSequence 和 Comparable

interface ArcadeGame<T1> : Game<T1> {
    override fun save(x: T1): T1
    override fun load(x: T1 & Any): T1 & Any // T1 是明确的非空类型
}

data class User(val name: String, val age: Int)

data class User(val name: String = "", val age: Int = 0)

data class Person(val name: String) {
    var age: Int = 0
}

val person1 = Person("John")
val person2 = Person("John")
person1.age = 10
person2.age = 20

println("person1 == person2: ${person1 == person2}")
// person1 == person2: true

println("person1 with age ${person1.age}: ${person1}")
// person1 with age 10: Person(name=John)

println("person2 with age ${person2.age}: ${person2}")
// person2 with age 20: Person(name=John)

fun copy(name: String = this.name, age: Int = this.age) = User(name, age)

val jack = User(name = "Jack", age = 1)
val olderJack = jack.copy(age = 2)

val jane = User("Jane", 35)
val (name, age) = jane
println("$name, $age years of age")
// Jane, 35 years of age

enum class Direction {
    NORTH, SOUTH, WEST, EAST
}

enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF)
}

enum class ProtocolState {
    WAITING {
        override fun signal() = TALKING
    },

    TALKING {
        override fun signal() = WAITING
    };

    abstract fun signal(): ProtocolState
}

enum class IntArithmetics : BinaryOperator<Int>, IntBinaryOperator {
    PLUS {
        override fun apply(t: Int, u: Int): Int = t + u
    },
    TIMES {
        override fun apply(t: Int, u: Int): Int = t * u
    };

    override fun applyAsInt(t: Int, u: Int) = apply(t, u)
}

enum class RGB { RED, GREEN, BLUE }

fun main() {
  for (color in RGB.entries) println(color.toString()) // prints RED, GREEN, BLUE
  println("The first color is: ${RGB.valueOf("RED")}") // prints "The first color is: RED"
}

println(RGB.RED.name)    // prints RED
println(RGB.RED.ordinal) // prints 0

enum class RGB { RED, GREEN, BLUE }

inline fun <reified T : Enum<T>> printAllValues() {
    println(enumEntries<T>().joinToString { it.name })
}

printAllValues<RGB>()
// RED, GREEN, BLUE

@JvmInline
value class Password(val value: String)

@JvmInline
value class Email(val value: String)

fun sendEmail(email: String) { // 接收普通字符串
}

fun sendEmail(email: Email) { // 接收 Email 类型
}

val myEmail: Email = Email("test@example.com")
val myString: String = "test@example.com"

sendEmail(myEmail) // 调用接收 Email 类型的函数
sendEmail(myString) // 调用接收普通字符串类型的函数

object MySingleton {
    val name = "Singleton"

    fun doSomething() {
        println("Doing something in the singleton")
    }
}

fun main() {
    println(MySingleton.name) // 访问单例对象的属性
    MySingleton.doSomething()  // 调用单例对象的方法
}

class MyClass {
    companion object {
        val constant = "Class Constant"

        fun create(): MyClass {
            return MyClass()
        }
    }
}

fun main() {
    println(MyClass.constant)  // 访问伴生对象的属性
    val instance = MyClass.create() // 调用伴生对象的方法
}

interface MyInterface {
    fun doSomething()
}

fun main() {
    val myObject = object : MyInterface {
        override fun doSomething() {
            println("Doing something in the anonymous object")
        }
    }

    myObject.doSomething()
}

import org.example.Message
import org.test.Message as TestMessage  // 现在可以用 TestMessage 代替 org.test.Message

interface MyInterface {
    fun bar() // 抽象方法，必须在实现类中实现
    fun foo() { // 带有默认实现的方法，实现类可以选择重写
        // 可选的方法体
    }
}

class Child : MyInterface {
    override fun bar() { // 必须实现 MyInterface 中的抽象方法 bar()
        // 方法体
    }
}

interface MyInterface {
    val prop: Int // 抽象属性，必须在实现类中实现

    val propertyWithImplementation: String
        get() = "foo" // 带有默认 getter 实现的属性

    fun foo() {
        print(prop)
    }
}

class Child : MyInterface {
    override val prop: Int = 29 // 必须实现 MyInterface 中的抽象属性 prop
}

interface Named {
    val name: String
}

interface Person : Named {
    val firstName: String
    val lastName: String

    override val name: String get() = "$firstName $lastName" // 提供了 name 属性的默认实现
}

data class Employee(
    override val firstName: String,
    override val lastName: String,
    val position: Position
) : Person // 不需要实现 name 属性，因为 Person 接口已经提供了默认实现

interface A {
    fun foo() { print("A") }
    fun bar()
}

interface B {
    fun foo() { print("B") }
    fun bar() { print("bar") }
}

class C : A {
    override fun bar() { print("bar") }
}

class D : A, B {
    override fun foo() {
        super<A>.foo() // 调用 A 接口的 foo() 实现
        super<B>.foo() // 调用 B 接口的 foo() 实现
    }

    override fun bar() {
        super<B>.bar() // 调用 B 接口的 bar() 实现
    }
}

fun interface KRunnable {
    fun invoke() // 唯一的抽象方法
}

fun interface IntPredicate {
    fun accept(i: Int): Boolean // 唯一的抽象方法
}

// 不使用 SAM 转换 (传统方式)
val isEven = object : IntPredicate {
    override fun accept(i: Int): Boolean {
        return i % 2 == 0
    }
}

// 使用 SAM 转换 (lambda 表达式)
val isEvenLambda: IntPredicate = IntPredicate { it % 2 == 0 }

fun main() {
    println("Is 7 even? - ${isEven.accept(7)}") // 输出: Is 7 even? - false
    println("Is 7 even? - ${isEvenLambda.accept(7)}") // 输出: Is 7 even? - false
}

interface Printer {
    fun print()
}

fun Printer(block: () -> Unit): Printer = object : Printer {
    override fun print() = block()
}

// 可以替换为：

fun interface Printer {
    fun print()
}

// 使用函数引用
// documentsStorage.addPrinter(::Printer)

@Deprecated(
    message = "使用函数式接口 Printer 代替",
    level = DeprecationLevel.HIDDEN
)
fun Printer(...) {...}

typealias IntPredicate = (i: Int) -> Boolean // IntPredicate 仅仅是函数类型 (i: Int) -> Boolean 的别名
  

fun interface IntPredicate {
    fun accept(i: Int): Boolean // IntPredicate 是一个真实的接口类型
}
  

// 文件名: example.kt
package foo

private fun foo() { ... } // 只在 example.kt 文件内可见

public var bar: Int = 5 // 在任何地方都可见
    private set         // setter 只在 example.kt 文件内可见

internal val baz = 6    // 在同一模块内可见

open class Outer {
    private val a = 1 // 只在 Outer 类内部可见
    protected open val b = 2 // 在 Outer 类及其子类中可见
    internal open val c = 3 // 在同一模块内可见
    val d = 4  // public (默认) 在任何地方都可见

    protected class Nested {
        public val e: Int = 5
    }
}

class Subclass : Outer() {
    // a 不可见
    // b, c 和 d 可见
    // Nested 和 e 可见

    override val b = 5   // 'b' 是 protected
    override val c = 7   // 'c' 是 internal
}

class Unrelated(o: Outer) {
    // o.a, o.b 不可见
    // o.c 和 o.d 可见 (同一模块)
    // Outer.Nested 不可见，Nested::e 也不可见
}

class C private constructor(a: Int) { ... } // 构造函数是 private

var <属性名>: <类型> by <表达式>

operator fun getValue(thisRef: Any?, property: KProperty<*>): 返回值类型 { ... }
  

operator fun setValue(thisRef: Any?, property: KProperty<*>, value: 新值类型) { ... }
  

val lazyValue: String by lazy {
    println("Computed!")
    "Hello"
}

fun main() {
    println(lazyValue) // 输出: Computed! \n Hello
    println(lazyValue) // 输出: Hello
}
  

import kotlin.properties.Delegates

class User {
    var name: String by Delegates.observable("<no name>") {
        prop, old, new ->
        println("Property ${prop.name} changed: $old -> $new")
    }
}

fun main() {
    val user = User()
    user.name = "first"  // 输出: Property name changed: <no name> -> first
    user.name = "second" // 输出: Property name changed: first -> second
}
  

import kotlin.properties.Delegates

class PositiveValueHolder {
    var value: Int by Delegates.vetoable(0) { property, oldValue, newValue ->
        newValue >= 0 // Only allow non-negative values
    }
}

fun main() {
    val holder = PositiveValueHolder()
    holder.value = 10   // OK
    println(holder.value) // Prints 10

    holder.value = -5   // Vetoed! Value remains 10
    println(holder.value) // Prints 10
}
  

var topLevelInt: Int = 0

class ClassWithDelegate(val anotherClassInt: Int)

class MyClass(var memberInt: Int, val anotherClassInstance: ClassWithDelegate) {
    var delegatedToMember: Int by this::memberInt
    var delegatedToTopLevel: Int by ::topLevelInt

    val delegatedToAnotherClass: Int by anotherClassInstance::anotherClassInt
}

var MyClass.extDelegated: Int by ::topLevelInt

class MyClass2 {
    var newName: Int = 0

    @Deprecated("Use 'newName' instead", ReplaceWith("newName"))
    var oldName: Int by this::newName
}

class User(val map: Map<String, Any?>) {
    val name: String by map
    val age: Int     by map
}

fun main() {
    val user = User(mapOf(
        "name" to "John Doe",
        "age"  to 25
    ))

    println(user.name) // 输出: John Doe
    println(user.age)  // 输出: 25
}

fun processData(data: String?) {
    val processedData by lazy {
        println("Processing data...")
        data?.uppercase() ?: "Default Value"
    }

    if (data != null && data.isNotEmpty()) {
        println("Using processed data: $processedData") // Triggers lazy initialization if 'data' is not null/empty
    } else {
        println("No data to process.")
    }
}

operator fun provideDelegate(thisRef: Any?, property: KProperty<*>): PropertyDelegate { ... }

import kotlin.properties.ReadOnlyProperty
import kotlin.reflect.KProperty

class ResourceDelegate<T>(private val initializer: () -> T) : ReadOnlyProperty<Any?, T> {
    private var value: T? = null

    override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        if (value == null) {
            value = initializer()
        }
        return value!!
    }
}

class ResourceLoader<T>(private val id: String) {
    operator fun provideDelegate(thisRef: Any?, property: KProperty<*>): ReadOnlyProperty<Any?, T> {
        println("Binding resource ${property.name} with ID $id")
        // Perform validation or customization here, e.g., check if resource ID is valid

        return ResourceDelegate {
            println("Initializing resource ${property.name} with ID $id")
            // Load resource based on ID (replace with actual resource loading logic)
            "Loaded Resource for ${property.name} (ID: $id)" as T // Type cast is necessary as T is only known at compile time.
        }
    }
}

class MyUI {
    val image: String by ResourceLoader("image_id")
    val text: String by ResourceLoader("text_id")
}

fun main() {
    val ui = MyUI()
    println(ui.image)
    println(ui.text)
}

class C {
    private val prop$delegate = MyDelegate()
    var prop: Type
        get() = prop$delegate.getValue(this, this::prop)
        set(value: Type) = prop$delegate.setValue(this, this::prop, value)
}
 

fun MutableList<Int>.swap(index1: Int, index2: Int) {
    val tmp = this[index1] // 'this' 指代列表
    this[index1] = this[index2]
    this[index2] = tmp
}

val list = mutableListOf(1, 2, 3)
list.swap(0, 2) // 'this' 在 'swap()' 内部将保存 'list' 的值

open class Shape
class Rectangle: Shape()

fun Shape.getName() = "Shape"
fun Rectangle.getName() = "Rectangle"

fun printClassName(s: Shape) {
    println(s.getName())
}

printClassName(Rectangle()) // 输出: Shape，因为 getName() 是根据 s 的声明类型 Shape 调用的

class Example {
    fun printFunctionType() { println("Class method") }
}

fun Example.printFunctionType() { println("Extension function") }

Example().printFunctionType() // 输出: Class method

class Example {
    fun printFunctionType() { println("Class method") }
}

fun Example.printFunctionType(i: Int) { println("Extension function #$i") }

Example().printFunctionType(1) // 输出: Extension function #1

fun Any?.toString(): String {
    if (this == null) return "null"
    // 空检查后，'this' 自动转换为非空类型，因此 toString() 解析为 Any 类的成员函数
    return toString()
}

val <T> List<T>.lastIndex: Int
    get() = size - 1

class House
val House.number = 1 // 错误：不允许对扩展属性进行初始化

class MyClass {
    companion object { }  // 将被称为 "Companion"
}

fun MyClass.Companion.printCompanion() { println("companion") }

fun main() {
    MyClass.printCompanion() // 输出: companion
}

package org.example.declarations

fun List<String>.getLongestString() { /*...*/ }

package org.example.usage

import org.example.declarations.getLongestString

fun main() {
    val list = listOf("red", "green", "blue")
    list.getLongestString()
}

class Host(val hostname: String) {
    fun printHostname() { print(hostname) }
}

class Connection(val host: Host, val port: Int) {
    fun printPort() { print(port) }

    fun Host.printConnectionString() {
        printHostname()   // 调用 Host.printHostname()
        print(":")
        printPort()   // 调用 Connection.printPort()
    }

    fun connect() {
        /*...*/
        host.printConnectionString()   // 调用扩展函数
    }
}

fun main() {
    Connection(Host("kotl.in"), 443).connect() //Host("kotl.in").printConnectionString()  // 错误，扩展函数在 Connection 外部不可用
}

class Connection {
    fun Host.getConnectionString() {
        toString()         // 调用 Host.toString()
        this@Connection.toString()  // 调用 Connection.toString()
    }
}

open class Base {
    open fun Base.printFunctionInfo() {
        println("Base extension function in BaseCaller")
    }

    open fun Derived.printFunctionInfo() {
        println("Derived extension function in BaseCaller")
    }
}

class Derived : Base() {
    override fun Base.printFunctionInfo() {
        println("Base extension function in DerivedCaller")
    }

    override fun Derived.printFunctionInfo() {
        println("Derived extension function in DerivedCaller")
    }
}

fun main() {
    BaseCaller().call(Base())   // "Base extension function in BaseCaller"
    DerivedCaller().call(Base())  // "Base extension function in DerivedCaller" - 分发接收者是虚拟解析的
    DerivedCaller().call(Derived())  // "Base extension function in DerivedCaller" - 扩展接收者是静态解析的
}

// 简化集合类型
typealias NodeSet = Set<Network.Node>

// 简化泛型 Map 类型
typealias FileTable<K> = MutableMap<K, MutableList<File>>

// 简化函数类型
typealias MyHandler = (Int, String, Any) -> Unit
typealias Predicate<T> = (T) -> Boolean

// 简化内部类
class A { inner class Inner }
class B { inner class Inner }
typealias AInner = A.Inner
typealias BInner = B.Inner

typealias Predicate<T> = (T) -> Boolean

fun foo(p: Predicate<Int>) = p(42) // 函数需要一个 Predicate<Int> 类型的参数

fun main() {
    val f: (Int) -> Boolean = { it > 0 } //  f 是一个 (Int) -> Boolean 类型的变量
    println(foo(f)) // 可以直接把 f 传给 foo，因为 Predicate<Int> 和 (Int) -> Boolean 本质上是一样的

    val p: Predicate<Int> = { it > 0 } // p 是一个 Predicate<Int> 类型的变量
    println(listOf(1, -2).filter(p)) // 可以用 p 来过滤列表，效果和直接用 (Int) -> Boolean 一样
}

fun double(x: Int): Int {
    return 2 * x
}

val result = double(2) // 调用 double 函数
Stream().read()       // 创建 Stream 类的实例并调用 read 函数

fun powerOf(number: Int, exponent: Int): Int { /* 函数体 */ }

fun powerOf(
    number: Int,
    exponent: Int, // 尾随逗号
) { /* 函数体 */ }

fun read(
    b: ByteArray,
    off: Int = 0,
    len: Int = b.size,
) { /* 函数体 */ }

open class A {
    open fun foo(i: Int = 10) { /*...*/ }
}

class B : A() {
    override fun foo(i: Int) { /*...*/ }  // 不允许设置默认值.
}

fun foo(
    bar: Int = 0,
    baz: Int,
) { /*...*/ }

foo(baz = 1) // 使用默认值 bar = 0

fun foo(
    bar: Int = 0,
    baz: Int = 1,
    qux: () -> Unit,
) { /*...*/ }

foo(1) { println("hello") }     // 使用默认值 baz = 1
foo(qux = { println("hello") }) // 使用默认值 bar = 0 和 baz = 1
foo { println("hello") }        // 使用默认值 bar = 0 和 baz = 1

fun reformat(
    str: String,
    normalizeCase: Boolean = true,
    upperCaseFirstLetter: Boolean = true,
    divideByCamelHumps: Boolean = false,
    wordSeparator: Char = ' ',
) { /*...*/ }

reformat(
    "String!",
    false,
    upperCaseFirstLetter = false,
    divideByCamelHumps = true,
    '_'
)

reformat("This is a long String!")

reformat("This is a short String!", upperCaseFirstLetter = false, wordSeparator = '_')

fun foo(vararg strings: String) { /*...*/ }

foo(strings = *arrayOf("a", "b", "c"))

fun printHello(name: String?): Unit {
    if (name != null)
        println("Hello $name")
    else
        println("Hi there!")
    // `return Unit` 或 `return` 是可选的
}

fun printHello(name: String?) { ... }

fun double(x: Int): Int = x * 2

fun double(x: Int) = x * 2

fun <T> asList(vararg ts: T): List<T> {
    val result = ArrayList<T>()
    for (t in ts) // ts 是一个 Array
        result.add(t)
    return result
}

val list = asList(1, 2, 3)

val a = arrayOf(1, 2, 3)
val list = asList(-1, 0, *a, 4)

val a = intArrayOf(1, 2, 3) // IntArray 是一个原始类型数组
val list = asList(-1, 0, *a.toTypedArray(), 4)

infix fun Int.shl(x: Int): Int { /* 函数体 */ }

// 使用中缀符号调用函数
1 shl 2

// 与以下相同
1.shl(2)

class MyStringCollection {
    infix fun add(s: String) { /*...*/ }

    fun build() {
        this add "abc"   // Correct
        add("abc")       // Correct
        //add "abc"        // Incorrect: the receiver must be specified
    }
}

fun dfs(graph: Graph) {
    fun dfs(current: Vertex, visited: MutableSet<Vertex>) {
        if (!visited.add(current)) return
        for (v in current.neighbors)
            dfs(v, visited)
    }

    dfs(graph.vertices[0], HashSet())
}

fun dfs(graph: Graph) {
    val visited = HashSet<Vertex>()
    fun dfs(current: Vertex) {
        if (!visited.add(current)) return
        for (v in current.neighbors)
            dfs(v)
    }

    dfs(graph.vertices[0])
}

class Sample {
    fun foo() { print("Foo") }
}

Sample().foo() // 创建 Sample 类的实例并调用 foo

fun <T> singletonList(item: T): List<T> { /*...*/ }

val eps = 1E-10 // "足够好", 可以是 10^-15

tailrec fun findFixPoint(x: Double = 1.0): Double =
    if (Math.abs(x - Math.cos(x)) < eps) x else findFixPoint(Math.cos(x))

fun <T, R> Collection<T>.fold(
    initial: R,                // 初始值
    combine: (acc: R, nextElement: T) -> R  // 组合函数
): R {
    var accumulator: R = initial
    for (element: T in this) {
        accumulator = combine(accumulator, element) // 调用组合函数
    }
    return accumulator
}
  

val numbers = listOf(1, 2, 3)

// 使用 Lambda 表达式 (最常见)
val sum = numbers.fold(0) { acc, number -> acc + number } // acc是累加值，number是集合中的元素
println(sum) // 输出：6

// 使用函数引用
val product = numbers.fold(1, Int::times) // Int::times 是一个函数引用，指向 Int 类的 times 函数
println(product) // 输出：6
  

typealias MyHandler = (String, Int) -> Unit

class IntTransformer: (Int) -> Int {
    override operator fun invoke(x: Int): Int = TODO() // 实现 invoke 方法
}

var sum = 0
numbers.forEach { sum += it }
println(sum) // 输出：numbers所有元素的总和

val sum: Int.(Int) -> Int = { other -> this + other }
println(1.sum(2)) // 输出：3

inline fun <T> lock(lock: Lock, body: () -> T): T { ... }

inline fun foo(inlined: () -> Unit, noinline notInlined: () -> Unit) { ... }

fun foo() {
    inlined {
        return // OK: the lambda is inlined, 直接从 foo() 返回
    }
}

inline fun f(crossinline body: () -> Unit) {
    val f = object: Runnable {
        override fun run() = body() // 这里调用 body()，所以不能使用非局部返回
    }
}

inline fun <reified T> TreeNode.findParentOfType(): T? { ... }

data class Point(val x: Int, val y: Int)

operator fun Point.unaryMinus() = Point(-x, -y) // 重载了负号操作符

val point = Point(10, 20)

fun main() {
   println(-point)  // 输出 "Point(x=-10, y=-20)"
}

data class Counter(val dayIndex: Int) {
    operator fun plus(increment: Int): Counter {
        return Counter(dayIndex + increment)
    }
}

class A { // 隐式标签 @A
    inner class B { // 隐式标签 @B
        fun Int.foo() { // 隐式标签 @foo
            val a = this@A // A 的 this (A 类的对象)
            val b = this@B // B 的 this (B 类的对象)

            val c = this // foo() 的接收者, 一个 Int (当前的 Int 值)
            val c1 = this@foo // foo() 的接收者, 一个 Int (当前的 Int 值)

            val funLit = lambda@ fun String.() {
                val d = this // funLit 的接收者, 一个 String (当前的 String 值)
            }

            val funLit2 = { s: String ->
                // foo() 的接收者, 因为闭合的 lambda 表达式
                // 没有接收者
                val d1 = this
            }
        }
    }
}

fun main() {
    fun printLine() { println("Local function") } // 局部函数

    class A {
        fun printLine() { println("Member function") } // 成员函数

        fun invokePrintLine(omitThis: Boolean = false) {
            if (omitThis) printLine() // 调用局部函数
            else this.printLine() // 调用成员函数
        }
    }

    A().invokePrintLine() // 输出: Member function
    A().invokePrintLine(omitThis = true) // 输出: Local function
}

annotation class Fancy

@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION,
        AnnotationTarget.TYPE_PARAMETER, AnnotationTarget.VALUE_PARAMETER,
        AnnotationTarget.EXPRESSION) // 可以用于类、函数、类型参数等
@Retention(AnnotationRetention.SOURCE) // 只保留在源码中，编译后会被丢弃
@MustBeDocumented // 应该包含在 API 文档中
annotation class Fancy

@Fancy class Foo {
    @Fancy fun baz(@Fancy foo: Int): Int {
        return (@Fancy 1)
    }
}

annotation class Special(val why: String)

@Special("example") class Foo {}

annotation class ReplaceWith(val expression: String)

annotation class Deprecated(
    val message: String,
    val replaceWith: ReplaceWith = ReplaceWith("")
)

@Deprecated("This function is deprecated, use === instead", ReplaceWith("this === other"))

import kotlin.reflect.KClass

annotation class Ann(val arg1: KClass<*>, val arg2: KClass<out Any>)

@Ann(String::class, Int::class) class MyClass

annotation class InfoMarker(val info: String)

fun processInfo(marker: InfoMarker): Unit = TODO()

fun main(args: Array<String>) {
    if (args.isNotEmpty())
        processInfo(getAnnotationReflective(args))
    else
        processInfo(InfoMarker("default"))
}

annotation class Suspendable

val f = @Suspendable { Fiber.sleep(10) }

class Example(@field:Ann val foo,    // 注解 Java 字段
              @get:Ann val bar,      // 注解 Java getter
              @param:Ann val quux)   // 注解 Java 构造函数参数

class Example {
     @set:[Inject VisibleForTesting]
     var collaborator: Collaborator
}

// Java
public @interface Ann {
    int intValue();
    String stringValue();
}
// Kotlin
@Ann(intValue = 1, stringValue = "abc") class C

// Java
public @interface AnnWithValue {
    String value();
}
// Kotlin
@AnnWithValue("abc") class C

// Java
public @interface AnnWithArrayValue {
    String[] value();
}
// Kotlin
@AnnWithArrayValue("abc", "foo", "bar") class C

// Java
public @interface AnnWithArrayMethod {
    String[] names();
}
@AnnWithArrayMethod(names = ["abc", "foo", "bar"])
class C

// Java
public @interface Ann {
    int value();
}
// Kotlin
fun foo(ann: Ann) {
    val i = ann.value // 直接访问 value 属性
}

@Repeatable
annotation class Tag(val name: String)

// 编译器会自动生成包含注解 @Tag.Container

@JvmRepeatable(Tags::class)
annotation class Tag(val name: String)

annotation class Tags(val value: Array<Tag>)

val (name, age) = person // 将 person 对象的属性赋值给 name 和 age 变量
println(name) // 可以直接使用 name 变量
println(age) // 也可以直接使用 age 变量

val name = person.component1() // 等价于 name = person 的第一个属性
val age = person.component2()  // 等价于 age = person 的第二个属性

for ((a, b) in collection) {
    // a 和 b 分别是集合中每个元素的 component1() 和 component2() 的返回值
}

data class Result(val result: Int, val status: String)

fun function(): Result {
    // ...
    return Result(123, "Success")
}

val (result, status) = function() // 直接将函数返回的 Result 对象解构
println(result) // 输出 123
println(status) // 输出 Success

val map = mapOf("key1" to "value1", "key2" to "value2")

for ((key, value) in map) {
    println("Key: $key, Value: $value")
}

val (_, status) = getResult() // 只关心 status，忽略第一个返回值

map.mapValues { (key, value) -> "$value!" } // 直接在 lambda 中解构键值对

map.mapValues { (_, value) -> "$value!" } // 如果不关心 key，可以用 _ 忽略

map.mapValues { (_, value): Map.Entry<Int, String> -> "$value!" } // 为整个解构参数指定类型
map.mapValues { (_, value: String) -> "$value!" } // 为 value 指定类型

class MyClass {
    fun myMethod() {}
}

fun main() {
    val kClass: KClass<MyClass> = MyClass::class
    println(kClass.simpleName) // 输出: MyClass

    if (MyClass() is MyClass) {
        println("It's a MyClass instance!")
    }

    val javaClass: Class<MyClass> = MyClass::class.java // 获取 Java Class 对象
}

fun isEven(x: Int): Boolean {
    return x % 2 == 0
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    val evenNumbers = numbers.filter(::isEven) // 将 isEven 函数作为参数传递
    println(evenNumbers) // 输出: [2, 4]

    val functionReference: (Int) -> Boolean = ::isEven // 显式声明类型
}

val myTopLevelProperty = "Hello"

class MyClass(val myMemberProperty: Int)

fun main() {
    println(::myTopLevelProperty.get()) // 输出: Hello
    println(::myTopLevelProperty.name) // 输出: myTopLevelProperty

    val myObject = MyClass(123)
    println(MyClass::myMemberProperty.get(myObject)) // 输出: 123
}

class MyClass(val message: String)

fun main() {
    val constructorReference: (String) -> MyClass = ::MyClass

    val myInstance = constructorReference("World") // 动态创建 MyClass 实例
    println(myInstance.message) // 输出: World
}

class MyClass {
    fun greet(name: String): String {
        return "Hello, $name!  I am ${this.hashCode()}"
    }

    val myProperty = 42
}

fun main() {
    val myInstance = MyClass()

    val boundFunction: (String) -> String = myInstance::greet // 绑定到 myInstance 的 greet 函数
    println(boundFunction("Alice")) // 输出: Hello, Alice! I am ... (myInstance 的 hashCode)

    val boundProperty: KProperty0<Int> = myInstance::myProperty // 绑定到 myInstance 的 myProperty 属性
    println(boundProperty.get()) // 输出: 42
}