与铸造

Question

免责声明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) 
} 

这有两个问题：较小的问题是内部subscribe一次性不照顾。理想情况下，我想将处置责任转交给回报价值，但我可以将处置者作为参数。我不在乎。

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

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

这意味着，我恐怕，编译器没有足够的信息来推断我想做什么，尽管我已经绝望地尝试帮助这个可怜的家伙增加了超过必要的提示。

Answer 1

如果你把这个配置为使用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) }) 

或者，如果你不喜欢的，指定的casted类型：要求类

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

键入作为参数是你的一个很好的接触。我没有想过这样做。