s/(Disposable|ActionDisposable)/AnyDisposable/g.

Author: andersio

Sources/Deprecations+Removals.swift

@@ -3,6 +3,11 @@ import Dispatch
 import Result
 
 // MARK: Unavailable methods in ReactiveSwift 2.0.
+extension AnyDisposable {
+	@available(*, unavailable, renamed:"init(_:)")
+	public convenience init(action: @escaping () -> Void) { fatalError() }
+}
+
 extension Lifetime {
 	@available(*, unavailable, renamed:"hasEnded")
 	public var isDisposed: Bool { fatalError() }
@@ -132,6 +137,9 @@ public func timer(interval: DispatchTimeInterval, on scheduler: DateScheduler) -
 public func timer(interval: DispatchTimeInterval, on scheduler: DateScheduler, leeway: DispatchTimeInterval) -> SignalProducer<Date, NoError> { fatalError() }
 
 // MARK: Obsolete types in ReactiveSwift 2.0.
+@available(*, unavailable, renamed:"AnyDisposable")
+public typealias ActionDisposable = AnyDisposable
+
 @available(*, unavailable, renamed:"Signal.Event")
 public typealias Event<Value, Error: Swift.Error> = Signal<Value, Error>.Event
 

Sources/Disposable.swift

@@ -40,64 +40,82 @@ extension UnsafeAtomicState where State == DisposableState {
 
 /// A type-erased disposable that forwards operations to an underlying disposable.
 public final class AnyDisposable: Disposable {
-	private let disposable: Disposable
+	private enum Backing {
+		case wrapping(Disposable)
+		case action(UnsafeAtomicState<DisposableState>, (() -> Void)?)
+	}
+
+	private var base: Backing
 
 	public var isDisposed: Bool {
-		return disposable.isDisposed
+		switch base {
+		case let .action(state, _):
+			return state.is(.disposed)
+		case let .wrapping(disposable):
+			return disposable.isDisposed
+		}
+	}
+
+	/// Initialize the disposable to run the given action upon disposal.
+	///
+	/// - parameters:
+	///   - action: A closure to run when calling `dispose()`.
+	public init(_ action: @escaping () -> Void) {
+		base = .action(UnsafeAtomicState(DisposableState.active), action)
 	}
 
 	public init(_ disposable: Disposable) {
-		self.disposable = disposable
+		base = .wrapping(disposable)
 	}
 
-	public func dispose() {
-		disposable.dispose()
+	public init?(_ disposable: Disposable?) {
+		guard let disposable = disposable else {
+			return nil
+		}
+		base = .wrapping(disposable)
 	}
-}
 
-/// A disposable that only flips `isDisposed` upon disposal, and performs no other
-/// work.
-public final class SimpleDisposable: Disposable {
-	private var state = UnsafeAtomicState(DisposableState.active)
+	deinit {
+		switch base {
+		case let .action(state, _):
+			state.deinitialize()
 
-	public var isDisposed: Bool {
-		return state.is(.disposed)
+		case .wrapping:
+			break
+		}
 	}
 
-	public init() {}
-
 	public func dispose() {
-		_ = state.tryDispose()
-	}
+		switch base {
+		case let .action(state, action):
+			if state.tryDispose() {
+				assert(action != nil, "Expected an action. Got none.")
+				action?()
+
+				// The discriminator and the state pointer remains constant, and only the
+				// optional closure reference is being overwritten with `nil`.
+				base = .action(state, nil)
+			}
 
-	deinit {
-		state.deinitialize()
+		case let .wrapping(disposable):
+			disposable.dispose()
+		}
 	}
 }
 
-/// A disposable that will run an action upon disposal.
-public final class ActionDisposable: Disposable {
-	private var action: (() -> Void)?
-	private var state: UnsafeAtomicState<DisposableState>
+/// A disposable that only flips `isDisposed` upon disposal, and performs no other
+/// work.
+public final class SimpleDisposable: Disposable {
+	private var state = UnsafeAtomicState(DisposableState.active)
 
 	public var isDisposed: Bool {
 		return state.is(.disposed)
 	}
 
-	/// Initialize the disposable to run the given action upon disposal.
-	///
-	/// - parameters:
-	///   - action: A closure to run when calling `dispose()`.
-	public init(action: @escaping () -> Void) {
-		self.action = action
-		self.state = UnsafeAtomicState(DisposableState.active)
-	}
+	public init() {}
 
 	public func dispose() {
-		if state.tryDispose() {
-			action?()
-			action = nil
-		}
+		_ = state.tryDispose()
 	}
 
 	deinit {
@@ -179,7 +197,7 @@ public final class CompositeDisposable: Disposable {
 			guard disposables != nil else { return nil }
 
 			let token = disposables!.insert(d)
-			return ActionDisposable { [weak self] in
+			return AnyDisposable { [weak self] in
 				self?.disposables.modify {
 					$0?.remove(using: token)
 				}
@@ -197,12 +215,51 @@ public final class CompositeDisposable: Disposable {
 	///            `disposable` is `nil`.
 	@discardableResult
 	public func add(_ action: @escaping () -> Void) -> Disposable? {
-		return add(ActionDisposable(action: action))
+		return add(AnyDisposable(action))
 	}
 
 	deinit {
 		state.deinitialize()
 	}
+
+	/// Adds the right-hand-side disposable to the left-hand-side
+	/// `CompositeDisposable`.
+	///
+	/// ````
+	///  disposable += producer
+	///      .filter { ... }
+	///      .map    { ... }
+	///      .start(observer)
+	/// ````
+	///
+	/// - parameters:
+	///   - lhs: Disposable to add to.
+	///   - rhs: Disposable to add.
+	///
+	/// - returns: An instance of `DisposableHandle` that can be used to opaquely
+	///            remove the disposable later (if desired).
+	@discardableResult
+	public static func +=(lhs: CompositeDisposable, rhs: Disposable?) -> Disposable? {
+		return lhs.add(rhs)
+	}
+
+	/// Adds the right-hand-side `ActionDisposable` to the left-hand-side
+	/// `CompositeDisposable`.
+	///
+	/// ````
+	/// disposable += { ... }
+	/// ````
+	///
+	/// - parameters:
+	///   - lhs: Disposable to add to.
+	///   - rhs: Closure to add as a disposable.
+	///
+	/// - returns: An instance of `DisposableHandle` that can be used to opaquely
+	///            remove the disposable later (if desired).
+	@discardableResult
+	public static func +=(lhs: CompositeDisposable, rhs: @escaping () -> ()) -> Disposable? {
+		return lhs.add(rhs)
+	}
 }
 
 /// A disposable that, upon deinitialization, will automatically dispose of
@@ -246,6 +303,44 @@ extension ScopedDisposable where Inner == AnyDisposable {
 	}
 }
 
+extension ScopedDisposable where Inner == CompositeDisposable {
+	/// Adds the right-hand-side disposable to the left-hand-side
+	/// `ScopedDisposable<CompositeDisposable>`.
+	///
+	/// ````
+	/// disposable += { ... }
+	/// ````
+	///
+	/// - parameters:
+	///   - lhs: Disposable to add to.
+	///   - rhs: Disposable to add.
+	///
+	/// - returns: An instance of `DisposableHandle` that can be used to opaquely
+	///            remove the disposable later (if desired).
+	@discardableResult
+	public static func +=(lhs: ScopedDisposable<CompositeDisposable>, rhs: Disposable?) -> Disposable? {
+		return lhs.inner.add(rhs)
+	}
+
+	/// Adds the right-hand-side disposable to the left-hand-side
+	/// `ScopedDisposable<CompositeDisposable>`.
+	///
+	/// ````
+	/// disposable += { ... }
+	/// ````
+	///
+	/// - parameters:
+	///   - lhs: Disposable to add to.
+	///   - rhs: Closure to add as a disposable.
+	///
+	/// - returns: An instance of `DisposableHandle` that can be used to opaquely
+	///            remove the disposable later (if desired).
+	@discardableResult
+	public static func +=(lhs: ScopedDisposable<CompositeDisposable>, rhs: @escaping () -> ()) -> Disposable? {
+		return lhs.inner.add(rhs)
+	}
+}
+
 /// A disposable that disposes of its wrapped disposable, and allows its
 /// wrapped disposable to be replaced.
 public final class SerialDisposable: Disposable {
@@ -293,78 +388,3 @@ public final class SerialDisposable: Disposable {
 		state.deinitialize()
 	}
 }
-
-/// Adds the right-hand-side disposable to the left-hand-side
-/// `CompositeDisposable`.
-///
-/// ````
-///  disposable += producer
-///      .filter { ... }
-///      .map    { ... }
-///      .start(observer)
-/// ````
-///
-/// - parameters:
-///   - lhs: Disposable to add to.
-///   - rhs: Disposable to add.
-///
-/// - returns: An instance of `DisposableHandle` that can be used to opaquely
-///            remove the disposable later (if desired).
-@discardableResult
-public func +=(lhs: CompositeDisposable, rhs: Disposable?) -> Disposable? {
-	return lhs.add(rhs)
-}
-
-/// Adds the right-hand-side `ActionDisposable` to the left-hand-side
-/// `CompositeDisposable`.
-///
-/// ````
-/// disposable += { ... }
-/// ````
-///
-/// - parameters:
-///   - lhs: Disposable to add to.
-///   - rhs: Closure to add as a disposable.
-///
-/// - returns: An instance of `DisposableHandle` that can be used to opaquely
-///            remove the disposable later (if desired).
-@discardableResult
-public func +=(lhs: CompositeDisposable, rhs: @escaping () -> ()) -> Disposable? {
-	return lhs.add(rhs)
-}
-
-/// Adds the right-hand-side disposable to the left-hand-side
-/// `ScopedDisposable<CompositeDisposable>`.
-///
-/// ````
-/// disposable += { ... }
-/// ````
-///
-/// - parameters:
-///   - lhs: Disposable to add to.
-///   - rhs: Disposable to add.
-///
-/// - returns: An instance of `DisposableHandle` that can be used to opaquely
-///            remove the disposable later (if desired).
-@discardableResult
-public func +=(lhs: ScopedDisposable<CompositeDisposable>, rhs: Disposable?) -> Disposable? {
-	return lhs.inner.add(rhs)
-}
-
-/// Adds the right-hand-side disposable to the left-hand-side
-/// `ScopedDisposable<CompositeDisposable>`.
-///
-/// ````
-/// disposable += { ... }
-/// ````
-///
-/// - parameters:
-///   - lhs: Disposable to add to.
-///   - rhs: Closure to add as a disposable.
-///
-/// - returns: An instance of `DisposableHandle` that can be used to opaquely
-///            remove the disposable later (if desired).
-@discardableResult
-public func +=(lhs: ScopedDisposable<CompositeDisposable>, rhs: @escaping () -> ()) -> Disposable? {
-	return lhs.inner.add(rhs)
-}

Sources/Flatten.swift

@@ -444,7 +444,7 @@ extension Signal where Value: SignalProducerProtocol, Error == Value.Error {
 		func startNextIfNeeded() {
 			while let producer = state.modify({ $0.dequeue() }) {
 				let producerState = UnsafeAtomicState<ProducerState>(.starting)
-				let deinitializer = ScopedDisposable(ActionDisposable(action: producerState.deinitialize))
+				let deinitializer = ScopedDisposable(AnyDisposable(producerState.deinitialize))
 
 				producer.startWithSignal { signal, inner in
 					let handle = disposable.add(inner)

Sources/FoundationExtensions.swift

@@ -35,7 +35,7 @@ extension Reactive where Base: NotificationCenter {
 				observer.send(value: notification)
 			}
 
-			return ActionDisposable {
+			return AnyDisposable {
 				base.removeObserver(notificationObserver)
 			}
 		}

Sources/Scheduler.swift

@@ -166,7 +166,7 @@ public final class UIScheduler: Scheduler {
 			DispatchQueue.main.async(execute: actionAndDecrement)
 		}
 
-		return disposable
+		return AnyDisposable(disposable)
 	}
 }
 
@@ -241,7 +241,7 @@ public final class QueueScheduler: DateScheduler {
 			}
 		}
 
-		return d
+		return AnyDisposable(d)
 	}
 
 	private func wallTime(with date: Date) -> DispatchWallTime {
@@ -271,7 +271,7 @@ public final class QueueScheduler: DateScheduler {
 			}
 		}
 
-		return d
+		return AnyDisposable(d)
 	}
 
 	/// Schedules a recurring action at the given interval and beginning at the
@@ -325,7 +325,7 @@ public final class QueueScheduler: DateScheduler {
 		timer.setEventHandler(handler: action)
 		timer.resume()
 
-		return ActionDisposable {
+		return AnyDisposable {
 			timer.cancel()
 		}
 	}
@@ -378,7 +378,7 @@ public final class TestScheduler: DateScheduler {
 		scheduledActions.sort { $0.less($1) }
 		lock.unlock()
 
-		return ActionDisposable {
+		return AnyDisposable {
 			self.lock.lock()
 			self.scheduledActions = self.scheduledActions.filter { $0 !== action }
 			self.lock.unlock()
@@ -483,7 +483,7 @@ public final class TestScheduler: DateScheduler {
 	public func schedule(after date: Date, interval: DispatchTimeInterval, leeway: DispatchTimeInterval = .seconds(0), action: @escaping () -> Void) -> Disposable? {
 		let disposable = SerialDisposable()
 		schedule(after: date, interval: interval, disposable: disposable, action: action)
-		return disposable
+		return AnyDisposable(disposable)
 	}
 
 	/// Advances the virtualized clock by an extremely tiny interval, dequeuing