Result enum that doesn't stop the stream

ApiResult.swift

import RxSwift

protocol ApiResultType {
    associatedtype ResultType
    var result: ApiResult<ResultType> { get }
}

enum ApiResult<T>: ApiResultType {
    typealias ResultType = T
    case success(T)
    case error(Error)
    
    var result: ApiResult<ResultType> {
        return self
    }
    
    func map<E>(_ transform: (T) -> E) -> ApiResult<E> {
        switch self {
        case let .success(value):
            return .success(transform(value))
        case let .error(error):
            return .error(error)
        }
    }
}

typealias ApiObservable<E> = Observable<ApiResult<E>>

extension ObservableType {
    func apiResult() -> ApiObservable<E> {
        return map({ ApiResult.success($0) }).catchError({ .just(ApiResult.error($0)) })
    }
}

extension Observable where Element: ApiResultType {
    func apiFlatMap<T>(_ transform: @escaping (Element.ResultType) -> ApiObservable<T>) -> ApiObservable<T> {
        return flatMap({ (element: Element) -> ApiObservable<T> in
            switch element.result {
            case let .success(some):
                return transform(some)
            case let .error(error):
                return ApiObservable<T>.just(.error(error))
            }
        })
    }
}