 				}
 				
 				if shouldSubscribe {
-					subscribeToSignalProducer(innerSignalProducer, state, observer, disposable)
+					subscribeToSignalProducer(innerSignalProducer, state)
 				}
 			}, error: { error in
 				sendError(observer, error)

/// emitted from `producer` complete.
public func concat<T, E>(producer: SignalProducer<SignalProducer<T, E>, E>) -> SignalProducer<T, E> {
	return SignalProducer { observer, disposable in
		let state = Atomic(ConcatState<T, E>())

		producer.startWithSignal { signal, signalDisposable in
			signal.observe(next: { innerSignalProducer in

		}
		
		if let nextSignalProducer = nextSignalProducer {
			subscribeToSignalProducer(nextSignalProducer, state)
		} else if isComplete {
			sendCompleted(state.value.observer)
		}
	})
}

private struct ConcatState<T, E: ErrorType> {
	/// The observer of a started `concat` producer.
	let observer: Signal<T, E>.Observer

	/// The top level disposable of a started `concat` producer.
	let disposable: CompositeDisposable

	init(observer: Signal<T, E>.Observer, disposable: CompositeDisposable) {
		self.observer = observer
		self.disposable = disposable
	}

	/// Whether the signal-of-signals has completed yet.
	var selfCompleted = false
	
