Swift3 带浇铸的RxSwift可观测滤波器

免责声明：我是半个Rx新手，所以这个想法很可能是完全疯狂的：）

我正在尝试编写

ObservableType

过滤器，它将只通过特定类型，但将通过该类型，而不是原始序列类型。这就是我到目前为止的想法：

extension ObservableType where Self.E: RxFilterableType {
  func filterByCast<T: RxFilterableType>(class: T.Type) -> Observable<T> {
    let retval = PublishSubject<T>()
    self.subscribe { event in
      switch event {
      case .next(let element):
        if let passed = element as? T {
          retval.onNext(passed)
        }
      case .error(let error):
        retval.onError(error)
      case .completed:
        retval.onCompleted()
      }
    }
    return retval
  }
}

func test() {
  class A: RxFilterableType {}
  class B: RxFilterableType {}

  let array: [RxFilterableType] = [A(), B()]
  let observable: Observable<RxFilterableType> = Observable.from(array)
  let observableCasted: Observable<A> = observable.filterByCast(class: A.self)
}

扩展ObservableType，其中Self.E:RxFilterableType{
func filterByCast（类：T.Type）->可观察{
let retval=PublishSubject（）
self.subscribe{event in
切换事件{
case.next（let元素）：
如果让通过=元素为？T{
retval.onNext（已通过）
}
案例错误（let error）：
retval.onError（错误）
案件.已完成：
retval.onCompleted（）
}
}
返回返回
}
}
func测试（）{
A类：RxFilterableType{}
B类：RxFilterableType{}
let数组：[RxFilterableType]=[A（），B（）]
让可观测：可观测=可观测。从（数组）
let ObservableCast:Observable=Observable.filterByCast（类：A.self）
}

这有两个问题：较小的问题是内部

subscribe

disposable没有得到处理。理想情况下，我希望将处置责任传递给返回值，但我可以将处置者作为参数。我不在乎

更大的问题是编译器对最后一个测试行的异议：

不支持将“RxFilterableType”用作符合协议“RxFilterableType”的具体类型

---

这意味着，我担心编译器没有足够的信息来推断我正在尝试做什么，尽管我在绝望地试图帮助这个可怜的家伙时添加了很多必要的提示。

如果你把它放在配置为使用RxSwift的游乐场上，它会起作用：

import RxSwift

extension ObservableType {
    func filterByCast<T>() -> Observable<T> {
        return self.filter { $0 is T }.map { $0 as! T }
    }
}

protocol Foo { }
struct A: Foo { }
struct B: Foo { }

let array: [Foo] = [A(), B()]
let observable = Observable.from(array)
let casted: Observable<A> = observable.filterByCast()
_ = casted.subscribe(onNext: { print($0) })

---

要求类类型作为参数是一个很好的选择。我没有想过要这么做。

那么你是想让一个操作员来做这件事

observable.filter{$0是一个}.map{$0是一个}

Ok这完全有效。我不知道，

ObservableType

有自己的

map

，它可以方便地完成我所需要的。作为参数的类类型是最方便的模式，因为可观测订阅通常是一个直接的匿名链，因此没有可用于推理的类型化可观测实例。

extension ObservableType {
    func filterByCast<T>(_ class: T.Type) -> Observable<T> {
        return self.filter { $0 is T }.map { $0 as! T }
    }
}

protocol Foo { }
struct A: Foo { }
struct B: Foo { }

let array: [Foo] = [A(), B()]
let observable = Observable.from(array)
let casted = observable.filterByCast(A.self)
_ = casted.subscribe(onNext: { print($0) })