 	/// already.
 	@warn_unused_result(message="Did you forget to call `start` on the producer?")
 	public func takeUntilReplacement(replacement: SignalProducer<T, E>) -> SignalProducer<T, E> {
-		return lift(ReactiveCocoa.takeUntilReplacement)(replacement)
+		return lift { (sg) -> Signal<T, E> -> Signal<T, E> in { $0.takeUntilReplacement(sg) } }(replacement)
 	}
 
 	/// Waits until `self` completes and then forwards the final `count` values

		return map(transform).flatten(strategy)
	}
}

// These free functions are to workaround compiler crashes when attempting
// to lift binary signal operators directly with closures.

private func combineLatestWith<T, U, E>(otherSignal: Signal<U, E>) -> Signal<T, E> -> Signal<(T, U), E> {
	return { $0.combineLatestWith(otherSignal) }
}

private func zipWith<T, U, E>(otherSignal: Signal<U, E>) -> Signal<T, E> -> Signal<(T, U), E> {
	return { $0.zipWith(otherSignal) }
}

private func sampleOn<T, E>(sampler: Signal<(), NoError>) -> Signal<T, E> -> Signal<T, E> {
	return { $0.sampleOn(sampler) }
}

private func takeUntil<T, E>(trigger: Signal<(), NoError>) -> Signal<T, E> -> Signal<T, E> {
	return { $0.takeUntil(trigger) }
}

private func takeUntilReplacement<T, E>(replacement: Signal<T, E>) -> Signal<T, E> -> Signal<T, E> {
	return { $0.takeUntilReplacement(replacement) }
}

	/// will also be interrupted.
	@warn_unused_result(message="Did you forget to call `start` on the producer?")
	public func combineLatestWith<U>(otherProducer: SignalProducer<U, E>) -> SignalProducer<(T, U), E> {
		return lift { sg -> Signal<T, E> -> Signal<(T, U), E> in { $0.combineLatestWith(sg) } }(otherProducer)
	}

	/// Delays `Next` and `Completed` events by the given interval, forwarding
