 	}
 }
 
-extension SignalState where U: EventProtocol, U.Value == Value, U.Error == Error {
+extension SignalStateSnapshot where U: EventProtocol, U.Value == Value, U.Error == Error {
 	/// Send the stored termination event to the observers.
 	@inline(__always)
 	func sendTerminated() {

	}
}

/// The status of a `Signal`.
///
/// - note: This three-case, multi-payload enum was verified to be a packed
///         object reference on i386, x86-64, armv7 and armv8 under the Swift
///         3.0.1 ABI. Should any changes be made to the enum, please first
///         verify that the change would not cause the enum to spill over the
///         size of an object reference on all platforms.
private enum SignalStatus<Value, Error: Swift.Error> {
	/// The `Signal` is alive.
	case alive(SignalState<Value, Error, ()>)

	/// The `Signal` has received a termination event, and is about to be
	/// terminated.
	case terminating(SignalState<Value, Error, Event<Value, Error>>)

	/// The `Signal` has terminated.
	case terminated
}

/// The state of a `Signal`.
///
/// As the amount of state would definitely span over a cache line,
/// `SignalState` is set to be a reference type so that we can atomically
/// update the reference instead.
///
/// - warning: In-place mutation should not be introduced to `SignalState`.
///            Copy the states and create a new instance instead.
private final class SignalState<Value, Error: Swift.Error, U> {
	/// The observers of the `Signal`.
	fileprivate let observers: Bag<Signal<Value, Error>.Observer>


				signal.sendLock.lock()
				// Start of the main protected section.

				if case let .alive(snapshot) = signal.state {
					snapshot.send(event)

					// Check if the status has been bumped to `terminating` due to a
					// concurrent or a recursive termination event.
					//
					// Note that as the check happens before acquiring `stateLock`, it
					// could be a false positive, and thus a second check after the lock
					// is acquired is mandatory.
					if case .terminating = signal.state {
						// Acquire `stateLock`. If the termination has still not yet been
						// handled, take it over and bump the status to `terminated`.
						signal.stateLock.lock()

						if case let .terminating(snapshot) = signal.state {
							signal.state = .terminated
							signal.stateLock.unlock()

							snapshot.sendTerminated()
							shouldDispose = true
						} else {
							signal.stateLock.unlock()
						}
					}
				}
