Result+Resolver.swift

public typealias Result<Success> = Swift.Result<Success, Error>

public protocol Executable {
    func execute()
}

extension Result {
    
    public typealias AssociatedResolver = Resolver<Success, Failure>
    
    public struct Resolver<Success, Failure: Error>: Executable {
        public typealias SuccessAction = (Success) -> Void
        public typealias FailureAction = (Failure) -> Void
        
        private var successAction: SuccessAction?
        private var failureAction: FailureAction?
        private var wrappedResult: Swift.Result<Success, Failure>
        
        public init(result: Swift.Result<Success, Failure>,
                    onSuccess successAction: SuccessAction? = .none,
                    onFailure failureAction: FailureAction? = .none) {
            self.wrappedResult = result
            self.successAction = successAction
            self.failureAction = failureAction
        }
        
        public func onSuccess(execute action: SuccessAction? = .none) -> Self {
            Resolver(result: wrappedResult, onSuccess: action, onFailure: failureAction)
        }
        
        public func onFailure(execute action: FailureAction? = .none) -> Self {
            Resolver(result: wrappedResult, onSuccess: successAction, onFailure: action)
        }
        
        public func execute() {
            switch wrappedResult {
            case let .success(value):
                successAction?(value)
            case let .failure(error):
                failureAction?(error)
            }
        }
        
    }
    
    public func resolve(_ successAction: AssociatedResolver.SuccessAction? = .none,
                 _ failureAction: AssociatedResolver.FailureAction? = .none) {
        resolve(success: successAction, failure: failureAction)
    }
    
    public func resolve(success successAction: AssociatedResolver.SuccessAction? = .none,
                 failure failureAction: AssociatedResolver.FailureAction? = .none) {
        resolver
            .onSuccess(execute: successAction)
            .onFailure(execute: failureAction)
            .execute()
    }
    
    public func resolver(success successAction: AssociatedResolver.SuccessAction? = .none,
                  failure failureAction: AssociatedResolver.FailureAction? = .none) -> AssociatedResolver {
        resolver
            .onSuccess(execute: successAction)
            .onFailure(execute: failureAction)
    }
    
    public var resolver: Resolver<Success, Failure> { .init(result: self) }
    
}

func test(result: Result<String>) {
    result.resolve(success: {
        print($0)
    }, failure: {
        print($0.localizedDescription)
    })
}

Back to index