Closure or dynamic protocol implementation?

DevAndArtist · December 11, 2018, 9:46pm

I marked this topic as #off-topic because it‘s a question about RxSwift in general.

Other than that, you‘re looking at the wrong subscribe method, there are multiple.

Check this one out:

ReactiveX/RxSwift/blob/main/RxSwift/ObservableType+Extensions.swift#L39


      
           
           Also, take in an object and provide an unretained, safe to use (i.e. not implicitly unwrapped), reference to it along with the events emitted by the sequence.
           
           - Note: If `object` can't be retained, none of the other closures will be invoked.
           
           - parameter object: The object to provide an unretained reference on.
           - parameter onNext: Action to invoke for each element in the observable sequence.
           - parameter onError: Action to invoke upon errored termination of the observable sequence.
           - parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
           - parameter onDisposed: Action to invoke upon any type of termination of sequence (if the sequence has
           gracefully completed, errored, or if the generation is canceled by disposing subscription).
           - returns: Subscription object used to unsubscribe from the observable sequence.
           */
          public func subscribe<Object: AnyObject>(
              with object: Object,
              onNext: ((Object, Element) -> Void)? = nil,
              onError: ((Object, Swift.Error) -> Void)? = nil,
              onCompleted: ((Object) -> Void)? = nil,
              onDisposed: ((Object) -> Void)? = nil
          ) -> Disposable {
              subscribe(

There is no magic here, just a different subscribe method that can take multiple closures.

Regarding the second question check out the implementation for AnyObserver.

Then it‘s just ˋobservable.subscribe(yourObserver)ˋ.