 	/// If the interval is 0, the timeout will be scheduled immediately. The producer
 	/// must complete synchronously (or on a faster scheduler) to avoid the timeout.
 	public func timeoutWithError(error: E, afterInterval interval: NSTimeInterval, onScheduler scheduler: DateSchedulerType) -> SignalProducer<T, E> {
-		return lift(ReactiveCocoa.timeoutWithError(error, afterInterval: interval, onScheduler: scheduler))
+		return lift { $0.timeoutWithError(error, afterInterval: interval, onScheduler: scheduler) }
 	}
 
 }

	/// producer returned from `scan`. That result is then passed to `combine` as the
	/// first argument when the next value is emitted, and so on.
	public func scan<U>(initial: U, _ combine: (U, T) -> U) -> SignalProducer<U, E> {
		return lift(ReactiveCocoa.scan(initial, combine))
	}

	/// Forwards only those values from `self` which do not pass `isRepeat` with
	/// respect to the previous value. The first value is always forwarded.
	public func skipRepeats(isRepeat: (T, T) -> Bool) -> SignalProducer<T, E> {
		return lift(ReactiveCocoa.skipRepeats(isRepeat))
	}

	/// Does not forward any values from `self` until `predicate` returns false,
	/// at which point the returned signal behaves exactly like `self`.
	public func skipWhile(predicate: T -> Bool) -> SignalProducer<T, E> {
		return lift(ReactiveCocoa.skipWhile(predicate))
	}

	/// Forwards events from `self` until `replacement` begins sending events.

extension SignalProducerType {
	/// Maps each value in the producer to a new value.
	public func map<U>(transform: T -> U) -> SignalProducer<U, E> {
		return lift { $0.map(transform) }
	}

	/// Maps errors in the producer to a new error.
	public func mapError<F>(transform: E -> F) -> SignalProducer<T, F> {
		return lift { $0.mapError(transform) }
	}
	
	/// Preserves only the values of the producer that pass the given predicate.
	public func filter(predicate: T -> Bool) -> SignalProducer<T, E> {
		return lift { $0.filter(predicate) }
	}

	/// Maps values from the producer and forwards the non-nil ones on the
	/// returned producer.
	public func filterMap<U>(transform: T -> U?) -> SignalProducer<U, E> {
		return lift { $0.filterMap(transform) }
	}

	/// Returns a producer that will yield the first `count` values from the
	/// input producer.
	public func take(count: Int) -> SignalProducer<T, E> {
		return lift { $0.take(count) }
	}

	/// Returns a signal that will yield an array of values when `signal` completes.
	public func collect() -> SignalProducer<[T], E> {
		return lift { $0.collect() }
	}

	/// Forwards all events onto the given scheduler, instead of whichever
	/// scheduler they originally arrived upon.
	public func observeOn(scheduler: SchedulerType) -> SignalProducer<T, E> {
		return lift { $0.observeOn(scheduler) }
	}

	/// Combines the latest value of the receiver with the latest value from
