fun mean(list: List<Int>): Double = when {
    list.isEmpty() -> // 返回一個(gè)值
    else -> list.sum().toDouble() / list.size
}

data class Toon(
    val firstName: String, // 首名字
    val lastName: String, // 姓氏
    val email: String? = null  // email
)
// 定義好一份數(shù)據(jù)
val toonMap: Map<String, Toon> = mapOf(
    "Joseph" to Toon("Joseph","Joestar", "joseph@jojo.com"),
    "Jonathan" to Toon("Jonathan","Joestar"),
    "Jotaro" to Toon("Jotaro","Kujo", "jotaro@jojo.com")
)

sealed class Option<out A> {
    abstract fun isEmpty(): Boolean
    internal object None : Option<Nothing>() {
        override fun isEmpty(): Boolean = true
        override fun equals(other: Any?): Boolean = other === null
        override fun hashCode(): Int = 0
    }
    internal data class Some<out A>(internal val value: A) : Option<A>() {
        override fun isEmpty(): Boolean = false
    }
    companion object {
        operator fun <A> invoke(a: A? = null): Option<A> =
            when (a) {
                null -> None
                else -> Some(a)
            }
    }
}

    fun getOrElse(default: @UnsafeVariance A): A = when(this) {
        is None -> default
        is Some -> value
    }

    fun max(list: List<Int>): Option<Int> = Option(list.max())
    val max1 = max(listOf(3, 1, 5, 2, 5)).getOrElse(0)  // 等于 7
    val max2 = max(listOf()).getOrElse(0)   // 等于 0

    fun getDefault(): Int = throw RuntimeException()
    val max1 = max(listOf(3, 1, 7, 2, 5)).getOrElse(getDefault())
    val max2 = max(listOf()).getOrElse(getDefault())

    fun getOrElse(default: () -> @UnsafeVariance A): A = when (this) {
        is None -> default()
        is Some -> value
    }
...
    val max1 = max(listOf(3, 1, 5, 2, 5)).getOrElse(::getDefault)  // 7
    val max2 = max(listOf()).getOrElse(::getDefault)   // 拋異常

    fun <B> map(f:(A) -> B): Option<B> = when(this) {
        is None -> None
        is Some -> Some(f(this.value))
    }

    fun <B> flatmap(f: (A) -> Option<B>): Option<B> = when (this) {
        is None -> None
        is Some -> f(this.value)
    }

fun orElse(default: () -> Option<@UnsafeVariance A>): Option<A> = map {<!--{cke_protected}{C}%3C!%2D%2D%20%2D%2D%3E--> this }.getOrElse(default)

// 比較智能的實(shí)現(xiàn), 因?yàn)橹耙呀?jīng)定義過(guò) flatmap, 所以可以直接組合
fun filter(p: (A) -> Boolean): Option<A> = flatmap { if (p(it)) this else None }

if (a.isSome()) {
   // 當(dāng) a 有值的操作
} else {
   // 當(dāng) a 沒(méi)有值的操作
}

data class Toon(
    val firstName: String, // 首名字
    val lastName: String, // 姓氏
    val email: Option<String> = Option(null)  // 可選email
) {
    companion object {
        operator fun invoke(firstName: String, lastName: String, email: String? = null) =
            Toon(firstName, lastName, Option(email))
    }
}
// 擴(kuò)展函數(shù)來(lái)實(shí)現(xiàn)前檢查模式, 以避免返回空引用
fun <K,V> Map<K,V>.getOption(key: K) = Option(this[key])
fun main() {
    val toons: Map<String, Toon> = mapOf(
        "Joseph" to Toon("Joseph", "Joestar", "joseph@jojo.com"),
        "Jonathan" to Toon("Jonathan", "Joestar"),
        "Jotaro" to Toon("Jotaro", "Kujo", "jotaro@jojo.com")
    )
    val joseph = toons.getOption("Joseph").flatmap { it.email }
    val jonathan = toons.getOption("Jonathan").flatmap { it.email }
    val jolyne = toons.getOption("Jolyne").flatmap { it.email }
    print(joseph.getOrElse { "No data" })
    print(jonathan.getOrElse { "No data" })
    print(jolyne.getOrElse { "No data" })
}

    val joseph = toons["Joseph"]?.email ?: "No data"
    val jonathan = toons["Jonathan"]?.email ?: "No data"
    val jolyne = toons["Jolyne"]?.email ?: "No data"
    ...

Some(value=joseph@jojo.com)
Option$None@0
No data

fun <A, B> lift(f: (A) -> B): (Option<A>) -> Option<B> = {<!--{cke_protected}{C}%3C!%2D%2D%20%2D%2D%3E--> it.map(f) }

val upperOption: (Option<String>) -> Option<String> = lift(String::toUpperCase)

fun <A, B> lift(f: (A) -> B): (Option<A>) -> Option<B> =
    {
        try {
            it.map(f)
        } catch (e: Exception) {
            Option()
        }
    }

fun <A, B> hLift(f: (A) -> B): (A) -> Option<B> = {
    try {
        Option(it).map(f)
    } catch (e: Exception) {
        Option()
    }
}

fun <A, B, C> map2(oa: Option<A>, ob: Option<B>, f: (A) -> (B) -> C): Option<C> =
    oa.flatmap { a -> ob.map { b -> f(a)(b) } }

sealed class Either<E, out A> {
    /**
     * Either<E, A> -> Either<E, B>
     */
    abstract fun <B> map(f: (A) -> B): Either<E, B>
    /**
     * (A) -> Either<E, B>
     */
    abstract fun <B> flatmap(f: (A) -> Either<E, B>): Either<E, B>
    fun getOrElse(default: () -> @UnsafeVariance A): A = when (this) {
        is Right -> this.value
        is Left -> default()
    }
    fun orElse(default: () -> Either<E, @UnsafeVariance A>): Either<E, A> = map { this }.getOrElse(default)
    /**
     * 錯(cuò)誤信息
     */
    internal class Left<E, out A>(internal val value: E) : Either<E, A>() {
        override fun <B> map(f: (A) -> B): Either<E, B> = Left(value)
        override fun <B> flatmap(f: (A) -> Either<@UnsafeVariance E, B>): Either<E, B> = Left(value)
    }
    /**
     * 正常信息
     */
    internal class Right<E, out A>(internal val value: A) : Either<E, A>() {
        override fun <B> map(f: (A) -> B): Either<E, B> = Right(f(value))

        override fun <B> flatmap(f: (A) -> Either<E, B>): Either<E, B> = f(value)
    }
    companion object {
        fun <E, A> left(value: E): Either<E, A> = Left(value)
        fun <E, A> right(value: A): Either<E, A> = Right(value)
    }
}

sealed class Result<out A> : Serializable {
    abstract fun <B> map(f: (A) -> B): Result<B>
    abstract fun <B> flatMap(f: (A) -> Result<B>): Result<B>
    internal class Success<out A>(internal val data: A) : Result<A>() {
        override fun <B> map(f: (A) -> B): Result<B> = try {
            Success(f(data))
        } catch (e: RuntimeException) {
            Failure(e)
        } catch (e: Exception) {
            Failure(RuntimeException(e))
        }
        override fun <B> flatMap(f: (A) -> Result<B>): Result<B> = try {
            f(data)
        } catch (e: RuntimeException) {
            Failure(e)
        } catch (e: Exception) {
            Failure(RuntimeException(e))
        }
    }
    internal object Empty : Result<Nothing>() {
        override fun <B> map(f: (Nothing) -> B): Result<B> = Empty
        override fun <B> flatMap(f: (Nothing) -> Result<B>): Result<B> = Empty
    }
    internal class Failure(val exception: RuntimeException) : Result<Nothing>() {
        override fun <B> map(f: (Nothing) -> B): Result<B> = Failure(exception)
        override fun <B> flatMap(f: (Nothing) -> Result<B>): Result<B> = Failure(exception)
    }
    /**
     * 沒(méi)有 / 錯(cuò)誤 返回一個(gè) default, 不能為空, 如果需要空, 使用 [getOrNull]
     */
    fun getOrElse(defaultValue: () -> @UnsafeVariance A): A = when (this) {
        is Success -> this.data
        else -> defaultValue()
    }
    /**
     * 沒(méi)有 / 錯(cuò)誤 返回一個(gè) Result-default, 不能為空
     */
    fun orElse(defaultValue: () -> Result<@UnsafeVariance A>): Result<A> = when (this) {
        is Success -> this
        else -> try {
            defaultValue()
        } catch (e: RuntimeException) {
            failure(e)
        } catch (e: Exception) {
            failure(RuntimeException(e))
        }
    }
    companion object {
        operator fun <A> invoke(a: A? = null): Result<A> = when (a) {
            null -> Failure(NullPointerException())
            else -> Success(a)
        }
        operator fun <A> invoke(): Result<A> = Empty
        fun <A> failure(message: String): Result<A> = Failure(IllegalStateException(message))
        fun <A> failure(exception: RuntimeException): Result<A> = Failure(exception)
        fun <A> failure(exception: Exception): Result<A> = Failure(IllegalStateException(exception))
    }
}

// 改變?cè)袛?shù)據(jù)結(jié)構(gòu)：
data class Toon(
    val firstName: String, // 首名字
    val lastName: String, // 姓氏
    val email: Result<String>
) {
    companion object {
        operator fun invoke(firstName: String, lastName: String, email: String? = null) =
            Toon(firstName, lastName, Result(email))
        operator fun invoke(firstName: String, lastName: String) =
            Toon(firstName, lastName, Result.Empty)
    }
}
// 創(chuàng)建一個(gè) Result 版本的getMap
fun <K, V> Map<K, V>.getResult(key: K) = when {
    this.containsKey(key) -> Result(this[key])
    else -> Result.Empty
}
fun main() {
    val toonMap: Map<String, Toon> = mapOf(
        "Joseph" to Toon("Joseph", "Joestar", "joseph@jojo.com"),
        "Jonathan" to Toon("Jonathan", "Joestar"),
        "Jotaro" to Toon("Jotaro", "Kujo", "jotaro@jojo.com")
    )
    val toon = getName()
        .flatMap(toonMap::getResult)
        .flatMap(Toon::email)
    print(toon)
}
fun getName(): Result<String> = try {
    validate(readLine())
} catch (e: IOException) {
    Result.failure(e)
}
fun validate(name: String?): Result<String> = when {
    name?.isNotEmpty() ?: false -> Result(name)
    else -> Result.failure(IOException())
}

    fun filter(p: (A) -> Boolean): Result<A> = flatMap {
        if (p(it)) this
        else failure("Condition not matched")
    }
    fun filter(message: String, p: (A) -> Boolean): Result<A> = flatMap {
        if (p(it)) this
        else failure(message)
    }

fun exists(p: (A) -> Boolean): Boolean = map(p).getOrElse(false)

abstract fun forEach(effect: (A) -> Unit)
// Success 實(shí)現(xiàn)
override fun forEach(effect: (A) -> Unit) = effect(data)
// Empty 實(shí)現(xiàn)
override fun forEach(effect: (Nothing) -> Unit) = Unit
// Failure 實(shí)現(xiàn)
override fun forEach(effect: (Nothing) -> Unit) = Unit

    abstract fun forEachOrElse(
        onSuccess: (A) -> Unit,
        onFailure: (java.lang.RuntimeException) -> Unit,
        onEmpty: () -> Unit
    )
// Success 實(shí)現(xiàn)
        override fun forEachOrElse(
            onSuccess: (A) -> Unit,
            onFailure: (java.lang.RuntimeException) -> Unit,
            onEmpty: () -> Unit
        ) = onSuccess(data)
// Empty 實(shí)現(xiàn)：
        override fun forEachOrElse(
            onSuccess: (Nothing) -> Unit,
            onFailure: (java.lang.RuntimeException) -> Unit,
            onEmpty: () -> Unit
        ) = onEmpty()    
// Failure 實(shí)現(xiàn)：
        override fun forEachOrElse(
            onSuccess: (Nothing) -> Unit,
            onFailure: (java.lang.RuntimeException) -> Unit,
            onEmpty: () -> Unit
        ) = onFailure(exception)    

    abstract fun forEach(
        onSuccess: (A) -> Unit = {},
        onFailure: (java.lang.RuntimeException) -> Unit = {},
        onEmpty: () -> Unit = {}

fun <A, B> lift(f: (A) -> B): (Result<A>) -> Result<B> = { it.map(f) }

fun <A, B, C> lift2(f: (A) -> (B) -> C): (Result<A>) -> (Result<B>) -> Result<C> = { a ->
    { b ->
        a.map(f).flatMap { b.map(it) }
    }
}
fun <A, B, C, D> lift3(f: (A) -> (B) -> (C) -> D): (Result<A>) -> (Result<B>) -> (Result<C>) -> Result<D> =
    { a -> { b -> { c -> a.map(f).flatMap { b.map(it) }.flatMap { c.map(it) } } } }

fun <A, B, C> map2(a: Result<A>, b: Result<B>, f: (A) -> (B) -> C): Result<C> = lift2(f)(a)(b)

fun getFirstName(): Result<String> = Result("Joseph")
fun getLastName(): Result<String> = Result("Jostar")
fun getMail(): Result<String> = Result("joseph@jojo.com")

var createPerson: (String) -> (String) -> (String) -> Toon =
    { x -> { y -> { z -> Toon(x, y, z) } } }
val toon = lift3(createPerson)(getFirstName())(getLastName())(getMail())

val toon = getFirstName()
    .flatMap { firstName ->
        getLastName().flatMap { lastName ->
            getMail().map { mail ->
                Toon(firstName, lastName, mail)
            }
        }
    }

val toon2: Result<Toon> = lift3 { x: String ->
    { y: String ->
        { z: String ->
            Toon(x, y, z)
        }
    }
}(getFirstName())(getLastName())(getMail())