Result Wrapper class

DataError.kt

sealed interface DataError: Error {
    enum class Remote: DataError{
        BAD_REQUEST,
        UNAUTHORIZED,
        REQUEST_TIMEOUT,
        FORBIDDEN,
        CONFLICT,
        TOO_MANY_REQUESTS,
        NO_INTERNET_CONNECTION,
        PAYLOAD_TOO_LARGE,
        NOT_FOUND,
        SERIALIZATION_ERROR,
        SERVER_ERROR,
        SERVICE_UNAVAILABLE,
        TIMEOUT,
        UNKNOWN

    }

    enum class Local: DataError{
        DISK_FULL,
        FILE_NOT_FOUND,
        UNKNOWN
    }
}

Error.kt

interface Error

Result.kt

sealed interface Result<out D,out E: Error> {
    data class Success<out D>(val data:D): Result<D, Nothing>
    data class Failure<out E: Error>(val error:E): Result<Nothing,E>
}

/**
@param T - Data,
E - Error,
R - Result

take T and return R and again take R and return R and E
* */

inline fun <T,E: Error,R> Result<T,E>.map(map:(T) -> R): Result<R,E>{
    return when(this){
        is Result.Success -> Result.Success(map(data))
        is Result.Failure -> Result.Failure(error)
    }
}

inline fun <T,E: Error> Result<T,E>.onSuccess(action:(T) -> Unit): Result<T,E>{
    return when(this){
        is Result.Success -> {
            action(data)
            this
        }
        is Result.Failure -> this
    }
}

inline fun <T,E: Error> Result<T,E>.onFailure(action:(E) -> Unit): Result<T,E>{
    return when(this){
        is Result.Success -> this
        is Result.Failure -> {
            action(error)
            this
        }
    }
}

typealias EmptyResult<E> = Result<Unit,E>


inline fun <T,E: Error> Result<T,E>.asEmptyResult(): EmptyResult<E>{
    return map {  }
}