ResultType

ResultType.swift

import Foundation

public enum ResultType<Value> {
    case success(Value)
    case failure(Swift.Error)
}

extension ResultType {
    public init(value: () throws -> Value) {
        do {
            self = try .success(value())
        } catch {
            self = .failure(error)
        }
    }

    public func resolve() throws -> Value {
        switch self {
        case .success(let value):
            return value
        case .failure(let error):
            throw error
        }
    }
}

extension ResultType {
    public func map<T>(_ transform: (Value) -> T) -> ResultType<T> {
        switch self {
        case .success(let value):
            return .success(transform(value))
        case .failure(let error):
            return .failure(error)
        }
    }

    public func flatMap<T>(_ transform: (Value) throws -> T) -> ResultType<T> {
        switch self {
        case .success(let value):
            do {
                return try .success(transform(value))
            } catch {
                return .failure(error)
            }
        case .failure(let error):
            return .failure(error)
        }
    }

    public func mapError<T: Swift.Error>(_ transform: (Swift.Error) -> T) -> ResultType {
        switch self {
        case .failure(let error):
            return .failure(transform(error))
        case .success:
            return self
        }
    }

    public func flatMapError<T: Swift.Error>(_ transform: (Swift.Error) throws -> T) -> ResultType {
        switch self {
        case .failure(let error):
            do {
                return try .failure(transform(error))
            } catch {
                return .failure(error)
            }
        case .success:
            return self
        }
    }
}