sealed class Result<T, E> {
    data class Ok<T, E>(val v: T): Result<T, E>()
    data class Error<T, E>(val e: E): Result<T, E>()

    inline val value: T get() = when(this) {
        is Ok -> this.v
        is Error -> throw RuntimeException("attempt to get value of ${this}")
    }

    inline val error: E get() = when(this) {
        is Ok -> throw RuntimeException("attempt to get error of ${this}")
        is Error -> this.e
    }

    inline val isOk: Boolean inline get() = when(this) {
        is Ok -> true
        is Error -> false
    }

    inline val isError: Boolean inline get() = !this.isOk

    // FUNCTOR

    @Suppress("UNCHECKED_CAST")
    inline infix fun <U> map(f: (T) -> (U)): Result<U, E> = when (this) {
        is Ok<T, E> -> Ok<U, E>(f(this.v))
        is Error<T, E> -> this as Error<U, E>
    }

    @Suppress("UNCHECKED_CAST")
    inline infix fun <U> mapErr(f: (E) -> (U)): Result<T, U> = when (this) {
        is Ok<T, E> -> this as Ok<T, U>
        is Error<T, E> -> Error<T, U>(f(this.e))
    }

    // MONAD

    @Suppress("UNCHECKED_CAST")
    inline infix fun <U> flatMap(f: (T) -> (Result<U, E>)): Result<U, E> = when (this) {
        is Ok<T, E> -> f(this.v)
        is Error<T, E> -> this as Error<U, E>
    }

    @Suppress("UNCHECKED_CAST")
    inline infix fun <U> flatMapErr(f: (E) -> (Result<T, U>)): Result<T, U> = when (this) {
        is Ok<T, E> -> this as Ok<T, U>
        is Error<T, E> -> f(this.e)
    }

    inline val seq: Sequence<T> get() = when(this){
        is Ok -> generateSequence(this.v, { _:T -> null })
        is Error -> generateSequence { null }
    }
}