 public struct SignalProducer<Value, Error: Swift.Error> {
 	public typealias ProducedSignal = Signal<Value, Error>
 
+	/// `core` is the actual implementation for this `SignalProducer`. It is responsible
+	/// of:
+	///
+	/// 1. handling the single-observer `start`; and
+	/// 2. building `Signal`s on demand via its `make()` method, which produces a
+	///    `Signal` with the associated side effect and interrupt handle.
 	fileprivate let core: SignalProducerCore<Value, Error>
 
 	/// Convert an entity into its equivalent representation as `SignalProducer`.

			let observerDidSetup = { startHandler(observer, Lifetime(disposable)) }
			let interruptHandle = AnyDisposable(observer.sendInterrupted)

			return SignalProducerCore.Product(signal: signal, observerDidSetup: observerDidSetup, interruptHandle: interruptHandle)
		}
	}


	///            `Signal` commences. Both the produced `Signal` and an interrupt handle
	///            of the signal would be passed to the closure.
	public func startWithSignal(_ setup: (_ signal: Signal<Value, Error>, _ interruptHandle: Disposable) -> Void) {
		let receipt = core.make()
		setup(receipt.signal, receipt.interruptHandle)
		guard !receipt.interruptHandle.isDisposed else { return }
		receipt.observerDidSetup()
	}
}

/// `SignalProducerCore` is the actual implementation of a `SignalProducer`.
///
/// While `SignalProducerCore` still requires all subclasses to be able to produce
/// instances of `Signal`s, the abstraction enables room of optimization for common
/// compositional and single-observer use cases.
internal class SignalProducerCore<Value, Error: Swift.Error> {
	/// `ProducedSignalReceipt` represents an instance of `Signal` created from a
	/// `SignalProducer`. In addition to the `Signal` itself, it includes also the
	/// starting side effect and an interrupt handle for this particular instance.
	///
	/// It is the responsibility of the `ProducedSignalReceipt` consumer to ensure the
	/// starting side effect is invoked exactly once, and is invoked after observations
	/// has properly setup.
	struct ProducedSignalReceipt {
		let signal: Signal<Value, Error>
		let observerDidSetup: () -> Void
		let interruptHandle: Disposable
	}

	func make() -> ProducedSignalReceipt {
		fatalError()
	}

	func start(_ observer: Signal<Value, Error>.Observer) -> Disposable {
		fatalError()
	}

	/// Perform an action upon every event from `self`. The action may generate zero or
