RxOptional extension mapEmptyToOptional

RxOptional+OptionalType+EmptyToNil.swift

import RxOptional

public protocol OptionalType {
    associatedtype OptionalElement
    var element: OptionalElement? { get }
    func asOptional() -> OptionalElement?
    func asNil() -> OptionalElement?
}

public extension OptionalType {

    func asOptional() -> OptionalElement? {
        return element
    }

    func asNil() -> OptionalElement? {
        return nil
    }
}

extension Optional: OptionalType {}
public extension Optional {
    public typealias OptionalElement = Wrapped
    public var element: OptionalElement? {
        switch self {
        case .none: return nil
        case .some(let element): return element
        }
    }
}

public extension ObservableConvertibleType where E: OptionalType, E.OptionalElement: Occupiable {

    typealias OptionalElement = E.OptionalElement
    /**
     Maps empty occupiable elements, to `Nil`

     - returns: `Observable` of source `Observable`'s occupiable elements, with empty occupiable elements mapped to `Nil`
     */
    public func mapEmptyToNil() -> Observable<E> {
        return self.asObservable().flatMapLatest { element -> Observable<E> in
            let optional = element.asOptional()
            guard let wrapped = optional, wrapped.isEmpty else {
                // no need to do anything
                return Observable<E>.just(element)
            }
            let observable = Observable<OptionalElement?>.just(nil)
            // swiftlint:disable:next force_cast
            return observable as! Observable<E>
        }
    }
}

public extension SharedSequenceConvertibleType where SharingStrategy == DriverSharingStrategy, E: OptionalType, E.OptionalElement: Occupiable {
    public func mapEmptyToNil() -> Driver<E> {
        return asObservable().mapEmptyToNil().asDriverOnErrorReturnEmpty()
    }
}