Rx variation for UseCase declaration

RxUseCase.swift

import Foundation
import RxSwift

enum Either<T> {
    case success(T)
    case error(Swift.Error)
    
    var successResult: T? {
        switch self {
        case .success(let result):
            return result
        case .error(_):
            return nil
        }
    }
}

protocol UseCaseProtocol {
    associatedtype ReturnType
    associatedtype Param
    func execute(_ params: Param, completion: @escaping ((Either<ReturnType>) -> Void))
}

struct UseCase<P, R> {
    typealias ReturnType = R
    typealias Param = P
    
    init<U>(_ useCase: U) where U: UseCaseProtocol, U.ReturnType == ReturnType, U.Param == Param {
        _execute = useCase.execute
    }
    
    func execute(_ params: P, completion: @escaping ((Either<R>) -> Void)) {
        _execute(params, completion)
    }
    
    func execute(_ params: P) -> Observable<R> {
        return Observable.create { (observable) in
            self._execute(params) { (either) in
                switch either {
                case .success(let response):
                    observable.onNext(response)
                case .error(let error):
                    observable.onError(error)
                }
                observable.onCompleted()
            }
            return Disposables.create()
        }
    }
    
    let _execute: (P,  @escaping (Either<R>) -> Void) -> Void
}