2016-04-19 10 views
2

Derzeit habe ich eine Funktion unwrapOptional erstellt, um den optionalen Eingang im Stream sicher auszupacken.RxSwift unwrap optionale praktische Funktion?

func unwrapOptional<T>(x: Optional<T>) -> Observable<T> { 
     return x.map(Observable.just) ?? Observable.empty() 
    } 

    let aOpt: String? = "aOpt" 
    _ = Observable.of(aOpt).flatMap(unwrapOptional).subscribeNext { x in print(x)} 

    let aNil: String? = nil 
    _ = Observable.of(aNil).flatMap(unwrapOptional).subscribeNext { x in print(x)} 

    let a: String = "a" 
    _ = Observable.of(a).flatMap(unwrapOptional).subscribeNext { x in print(x)} 

    // output 
    aOpt 
    a 

Was ich will, zu archivieren, ist eine praktische Funktion zu erstellen, anstatt flatMap(unwrapOptional) zu verwenden, zum Beispiel

Observable.of(a).unwrapOptional() 

Etwas, was ich tun wollte, aber es kompiliert nie ...

extension ObservableType { 
    func unwrapOptional<O : ObservableConvertibleType>() -> RxSwift.Observable<O.E> { 
     return self.flatMap(unwrapOptional) 
    } 
} 

Antwort

4

Sie die auf beobachtbaren unwrapOptional Methode nur zu arbeiten möchten, dass habe einen optionalen Typ.

Also müssen Sie irgendwie die Element von Observable zu Conformen mit dem Optional Protokoll einschränken.

extension Observable where Element: OptionalType { 
    /// Returns an Observable where the nil values from the original Observable are 
    /// skipped 
    func unwrappedOptional() -> Observable<Element.Wrapped> { 
     return self.filter { $0.asOptional != nil }.map { $0.asOptional! } 
    } 
} 

Leider Swift wird nicht definiert, ein solches Protokoll (OptionalType). Sie müssen es also auch selbst definieren

/// Represent an optional value 
/// 
/// This is needed to restrict our Observable extension to Observable that generate 
/// .Next events with Optional payload 
protocol OptionalType { 
    associatedtype Wrapped 
    var asOptional: Wrapped? { get } 
} 

/// Implementation of the OptionalType protocol by the Optional type 
extension Optional: OptionalType { 
    var asOptional: Wrapped? { return self } 
}