 					// So we do not need to guard it with an explicit lock.
 					//
 					// Specifically, senders are serialized by `sendLock`, and can react
-					// to and bump the status to `red` only after they see the status
-					// being `yellow`.
+					// to and bump the status to `terminated` only after they see the
+					// status being `terminating`.
 					//
-					// `yellow` can happen only once, since `state` being swapped with
-					// `nil` is a point of no return.
+					// `terminating` can happen only once in the lifetime of a `Signal`,
+					// since `state` being swapped with `nil` is a point of no return.
 					//
 					// Even in the case that both a previous sender and its successor see
-					// `yellow`, the senders are still bound to the `sendLock`. So
+					// `terminating`, the senders are still bound to the `sendLock`. So
 					// whichever sender loses the battle of acquring `sendLock` is
-					// guaranteed to be blocked by a status of `red`.
-					signal.status = .yellow(SignalTerminationSnapshot(state: state, event: event))
+					// guaranteed to see a status of `terminated`, and eventually be
+					// blocked.
+					signal.status = .terminating(SignalTerminationSnapshot(state: state, event: event))
 
 					if signal.sendLock.try() {
-						if case let .yellow(state) = signal.status {
+						if case let .terminating(state) = signal.status {
 							state.send()
-							signal.status = .red
+							signal.status = .terminated
 						}
 						signal.sendLock.unlock()
 						signal.swapDisposable()?.dispose()

	/// The state of the signal. `nil` if the signal has terminated.
	private let state: Atomic<SignalState<Value, Error>?>

	/// Holds the status of the signal. Implicitly protected by `state` and
	/// `sendLock`.
	private var status: SignalStatus<Value, Error>

	/// Used to ensure that events are serialized during delivery to observers.

		generatorDisposable = generator(observer)
	}

	/// Swap the generator disposable with `nil`.
	///
	/// - returns:
	///   The generator disposable, or `nil` if it has been disposed of.
	@inline(__always)
	private func swapDisposable() -> Disposable? {
		if let d = generatorDisposable {
