 					// Check if a downstream consumer or a concurrent sender has
 					// interrupted the signal.
 					if let state = terminationState {
-						interrupt(state.observers, event: terminationEvent!)
+						terminate(with: state)
 						shouldDispose = true
 					}
 				}

	public init(_ generator: (Observer) -> Disposable?) {
		state = Atomic(SignalState())

		/// WARNING:
		/// The implementation assumes 32- or 64-bit platforms with 64 byte cache
		/// lines. It might break if the granularity of the cache coherence is
		/// decreased, but this is very unlikely to happen.

		/// Holds the final signal state captured by a termination event. If it
		/// is set, the Signal should terminate as soon as possible. Implicitly
		/// protected by `state` and `sendLock`.
		var terminationState: SignalState<Value, Error>? = nil

		/// The termination event received.
		///
		/// Do not pack it with `terminationState`, or the packed tuple might span
		/// over a cache line, resulting in all kinds of weird corrupted states.
		var terminationEvent: Event<Value, Error>? = nil

		/// Used to track if the signal has terminated. Protected by `sendLock`.
		var terminated = false

				// the disposal would be delegated to the current sender, or
				// occasionally one of the senders waiting on `sendLock`.
				if let state = signal.state.swap(nil) {
					terminationState = SignalTerminationState(state: state,
					                                          event: event)

					// Writes to `terminationState` are implicitly synchronized. So we do
					// not need to guard it with locks.
