 		return SignalProducer<U, F>(SignalCore {
 			// Transform the `Signal`, and pass through the `didCreate` side effect and
 			// the interruptHandle.
-			let instance = self.core.make()
-			return .init(signal: transform(instance.signal),
-			             observerDidSetup: instance.observerDidSetup,
-			             interruptHandle: instance.interruptHandle)
+			let receipt = self.core.make()
+			return .init(signal: transform(receipt.signal),
+			             observerDidSetup: receipt.observerDidSetup,
+			             interruptHandle: receipt.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) {
		return core.startWithSignal(setup)
	}
}

internal class SignalProducerCore<Value, Error: Swift.Error> {
	/// Wraps a closure which, when invoked, produces a new instance of `Signal`, a
	/// customized `observerDidSetup` post-creation side effect for the `Signal` and a
	/// disposable to interrupt the produced `Signal`.
	///
	/// Unlike the safe `startWithSignal(_:)` API, `builder` shifts the responsibility of
	/// invoking the post-creation side effect to the caller, while it takes from the
	/// caller the responsibility of the `Signal` creation.
	///
	/// The design allows producer lifting to be as efficient as native `Signal`
	/// operators, by eliminating the unnecessary relay `Signal` imposed by the old
	/// `startWithSignal(_:)`, regardless of the fact that lifted operators can rely on
	/// the upstreams for producer interruption.
	///
	/// `observerDidSetup` must be invoked before any other post-creation side effect.
	struct Product {
		let signal: Signal<Value, Error>
		let observerDidSetup: () -> Void
		let interruptHandle: Disposable
	}

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

	func start(_ observer: Signal<Value, Error>.Observer) -> Disposable {
		var disposable: Disposable!

		startWithSignal { signal, innerDisposable in
			signal.observe(observer)
			disposable = innerDisposable
		}

		return disposable
	}

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

		})
	}

	internal override func make() -> ProducedSignalReceipt {
		let product = source.make()
		let signal = Signal<Value, Error> { observer in
			return product.signal.observe(.init(observer, transform))
		}

		return ProducedSignalReceipt(signal: signal,
		                             observerDidSetup: product.observerDidSetup,
		                             interruptHandle: product.interruptHandle)
	}
}

/// `EventGeneratingCore` wraps a generator closure that would be invoked upon a produced
/// `Signal` when started. The generator closure is passed only the input observer and the
/// cancel disposable.
///
/// It is intended for constant `SignalProducers`s that synchronously emits all events
/// without escaping the `Observer`.
private final class EventGeneratingCore<Value, Error: Swift.Error>: SignalProducerCore<Value, Error> {
	private let generator: (Signal<Value, Error>.Observer, Disposable) -> Void

