RxSwift 展开可选的方便功能？

Question

目前我已经创建了一个函数unwrapOptional来安全地解包流中的可选输入。

    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

我想要存档的是创建一个方便的函数而不是使用 flatMap(unwrapOptional)，例如

Observable.of(a).unwrapOptional()

我尝试做的事情，但它从未编译...

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

Answer 1

在 https://github.com/RxSwiftCommunity/RxSwift-Ext 结账 unwrap :)

或https://github.com/RxSwiftCommunity/RxOptional

目前，您应该 RxOptional 满足您的个人需求
但是，RxSwift-Ext 将在接下来的 2-3 个月内呈指数增长:)

Answer 2

您希望 unwrapOptional 方法仅适用于具有可选类型的可观察对象。

所以你必须以某种方式限制 Observable 的 Element 以符合 Optional 协议。

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 { [=10=].asOptional != nil }.map { [=10=].asOptional! }
    }
}

不幸的是，Swift 没有定义这样的协议 (OptionalType)。所以还需要自己定义

/// 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 }
}

Answer 3

这是一个不需要 OptionalType 的版本（来自）

extension Observable {

    /// Returns an `Observable` where the nil values from the original `Observable` are skipped
    func unwrap<T>() -> Observable<T> where Element == T? {
        self
            .filter { [=10=] != nil }
            .map { [=10=]! }
    }
}

Answer 4

RxSwift 现在支持 compactMap()。所以，现在您可以执行以下操作：

func unwrap(_ a: Observable<Int?>) -> Observable<Int> {
  return a.compactMap { [=10=] }
}

RxSwift 展开可选的方便功能？

RxSwift unwrap optional handy function?

swift

rx-swift