Data, Sealed & Enum Classes

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

fun main() {
    val a = PlainPoint(1, 2)
    val b = PlainPoint(1, 2)
    println(a == b)          // compares references

    val p = Point(1, 2)
    val q = Point(1, 2)
    println(p == q)          // compares x and y
    println(p)               // generated toString
    println(p.hashCode() == q.hashCode())
    println(setOf(p, q).size)
}

data class User(val name: String) {
    var loginCount = 0
}

fun main() {
    val a = User("Ada")
    val b = User("Ada")
    a.loginCount = 5
    println(a == b)
    println(a)
}

data class Order(val id: Int, val item: String, val qty: Int, val paid: Boolean = false)

fun main() {
    val order = Order(7, "Keyboard", 1)
    val paid = order.copy(paid = true)
    println(order)
    println(paid)

    val (id, item, qty) = paid
    println("#$id: $qty x $item")

    val (_, name) = order     // skip a component with _
    println(name)
}

fun minMax(xs: List<Int>): Pair<Int, Int> = xs.min() to xs.max()

fun main() {
    val stock = mapOf("apples" to 4, "pears" to 0)
    for ((fruit, count) in stock) {
        println("$fruit -> $count")
    }
    val (lo, hi) = minMax(listOf(5, 2, 9))
    println("lo=$lo hi=$hi")
}

enum class Plan(val monthlyPrice: Int, val seats: Int) {
    FREE(0, 1),
    TEAM(12, 10),
    ENTERPRISE(40, 500);   // semicolon before members

    fun yearly(): Int = monthlyPrice * 12
    val isPaid: Boolean get() = monthlyPrice > 0
}

fun main() {
    for (p in Plan.entries) {
        println("${p.ordinal} ${p.name}: ${p.yearly()}/yr paid=${p.isPaid}")
    }
    val chosen = Plan.valueOf("TEAM")
    println(chosen.seats)
}

enum class Op(val symbol: String) {
    ADD("+") { override fun apply(a: Int, b: Int) = a + b },
    MUL("*") { override fun apply(a: Int, b: Int) = a * b };

    abstract fun apply(a: Int, b: Int): Int
}

enum class Light { RED, AMBER, GREEN }

fun next(l: Light): Light = when (l) {
    Light.RED -> Light.GREEN
    Light.GREEN -> Light.AMBER
    Light.AMBER -> Light.RED
}

fun main() {
    for (op in Op.entries) println("6 ${op.symbol} 7 = ${op.apply(6, 7)}")
    println(next(Light.RED))
}

sealed interface Shape
data class Circle(val r: Double) : Shape
data class Rect(val w: Double, val h: Double) : Shape
data object Dot : Shape

fun area(s: Shape): Double = when (s) {
    is Circle -> 3.0 * s.r * s.r      // s is smart-cast to Circle
    is Rect -> s.w * s.h
    Dot -> 0.0
}

fun main() {
    val shapes = listOf(Circle(2.0), Rect(3.0, 4.0), Dot)
    for (s in shapes) println("$s -> ${area(s)}")
}

object Counter {
    private var n = 0
    fun next(): Int = ++n
}

class Temperature private constructor(val celsius: Double) {
    companion object {
        const val FREEZING = 0.0
        fun fromFahrenheit(f: Double) = Temperature((f - 32) * 5 / 9)
    }
}

object Plain
data object Loading

fun main() {
    Counter.next(); Counter.next()
    println(Counter.next())
    println(Temperature.fromFahrenheit(212.0).celsius)
    println(Temperature.FREEZING)
    println(Loading)
    println(Plain.toString().startsWith("Plain@"))
}

@JvmInline
value class UserId(val raw: Long)

@JvmInline
value class Email(val raw: String) {
    init { require("@" in raw) { "not an email: $raw" } }
    val domain: String get() = raw.substringAfter("@")
}

fun sendWelcome(id: UserId, to: Email) = println("user ${id.raw} -> ${to.raw} (${to.domain})")

fun main() {
    sendWelcome(UserId(42), Email("[email protected]"))
    // sendWelcome(Email("[email protected]"), UserId(42))  // does not compile
    println(UserId(1) == UserId(1))
}

sealed interface UiState {
    data object Loading : UiState
    data class Success(val items: List<String>) : UiState
    data class Error(val message: String, val canRetry: Boolean) : UiState
}

fun render(state: UiState): String = when (state) {
    UiState.Loading -> "[spinner]"
    is UiState.Success ->
        if (state.items.isEmpty()) "Nothing here yet" else state.items.joinToString(", ")
    is UiState.Error -> "Error: ${state.message}" + if (state.canRetry) " [Retry]" else ""
}

fun main() {
    val states = listOf(
        UiState.Loading,
        UiState.Success(listOf("Milk", "Eggs")),
        UiState.Success(emptyList()),
        UiState.Error("offline", canRetry = true),
    )
    states.forEach { println(render(it)) }
}

sealed interface ParseResult {
    data class Ok(val value: Int) : ParseResult
    data class Invalid(val input: String) : ParseResult
    data object Blank : ParseResult
}

fun parseAge(s: String): ParseResult {
    if (s.isBlank()) return ParseResult.Blank
    val n = s.trim().toIntOrNull() ?: return ParseResult.Invalid(s)
    return ParseResult.Ok(n)
}

fun main() {
    for (input in listOf("42", "forty", "  ")) {
        val msg = when (val r = parseAge(input)) {
            is ParseResult.Ok -> "age ${r.value}"
            is ParseResult.Invalid -> "'${r.input}' is not a number"
            ParseResult.Blank -> "please type something"
        }
        println(msg)
    }
}