 	/// but makes it easier to combine with other producers that may error; for
 	/// example, with operators like `combineLatestWith`, `zipWith`, `flatten`, etc.
 	public func promoteErrors<F: ErrorType>() -> SignalProducer<T, F> {
-		return lift(ReactiveCocoa.promoteErrors(F))
+		return lift { $0.promoteErrors() }
 	}
 }
 

	/// Waits until `self` completes and then forwards the final `count` values
	/// on the returned producer.
	public func takeLast(count: Int) -> SignalProducer<T, E> {
		return lift(ReactiveCocoa.takeLast(count))
	}

	/// Forwards any values from `self` until `predicate` returns false,
	/// at which point the returned producer will complete.
	public func takeWhile(predicate: T -> Bool) -> SignalProducer<T, E> {
		return lift(ReactiveCocoa.takeWhile(predicate))
	}

	/// Zips elements of two producers into pairs. The elements of any Nth pair
	/// are the Nth elements of the two input producers.
	public func zipWith<U>(otherSignal: SignalProducer<U, E>) -> SignalProducer<(T, U), E> {
		return lift(ReactiveCocoa.zipWith)(otherSignal)
	}

	/// Applies `operation` to values from `self` with `Success`ful results
	/// forwarded on the returned producer and `Failure`s sent as `Error` events.
	public func attempt(operation: T -> Result<(), E>) -> SignalProducer<T, E> {
		return lift(ReactiveCocoa.attempt(operation))
	}

	/// Applies `operation` to values from `self` with `Success`ful results mapped
	/// on the returned producer and `Failure`s sent as `Error` events.
	public func attemptMap<U>(operation: T -> Result<U, E>) -> SignalProducer<U, E> {
		return lift(ReactiveCocoa.attemptMap(operation))
	}

	/// Throttle values sent by the receiver, so that at least `interval`

	/// Forwards only those values from `self` which are not duplicates of the
	/// immedately preceding value. The first value is always forwarded.
	public func skipRepeats() -> SignalProducer<T, E> {
		return lift { $0.skipRepeats() }
	}
}

