 			let onError = { sendError(observer, $0) }
 			let onBothCompleted = { sendCompleted(observer) }
 			let onInterrupted = { sendInterrupted(observer) }
+
+			let disposable = CompositeDisposable()
+			disposable += observeWithStates(self.signal, signalState, otherState, lock, onBothNext, onError, onBothCompleted, onInterrupted)
+			disposable += observeWithStates(otherSignal, otherState, signalState, lock, onBothNext, onError, onBothCompleted, onInterrupted)
 			
-			let signalDisposable = observeWithStates(signal, signalState, otherState, lock, onBothNext, onError, onBothCompleted, onInterrupted)
-			let otherDisposable = observeWithStates(otherSignal, otherState, signalState, lock, onBothNext, onError, onBothCompleted, onInterrupted)
-			
-			return CompositeDisposable(ignoreNil([ signalDisposable, otherDisposable ]))
+			return disposable
 		}
 	}
 }

///
/// `Error` and `Interrupted` events are always scheduled immediately.
public func delay<T, E>(interval: NSTimeInterval, onScheduler scheduler: DateSchedulerType) -> Signal<T, E> -> Signal<T, E> {
	precondition(interval >= 0)

	return { signal in
		return Signal { observer in
			return signal.observe { event in
				switch event {
				case .Error, .Interrupted:
					scheduler.schedule {

			}
		}
	}
}

/// Maps errors in the signal to a new error.
public func mapError<T, E, F>(transform: E -> F) -> Signal<T, E> -> Signal<T, F> {
	return { $0.mapError(transform) }
}

extension SignalType {
	public func mapError<F>(transform: E -> F) -> Signal<T, F> {
		return Signal { observer in
			return self.signal.observe { event in
