 		}
 	}
 
-	/// Concatenates `signal` after the receiver.
-	public func concat(signal: ColdSignal) -> ColdSignal {
-		return ColdSignal { subscriber in
-			let serialDisposable = SerialDisposable()
-			subscriber.disposable.addDisposable(serialDisposable)
-
-			serialDisposable.innerDisposable = self.start(Subscriber { event in
-				switch event {
-				case let .Completed:
-					serialDisposable.innerDisposable = signal.start(subscriber)
-
-				default:
-					subscriber.put(event)
-				}
-			})
-		}
-	}
-
 	/// Merges a signal of signals down into a single signal, biased toward the
 	/// signals added earlier.
 	///

	var latestValue: T?
	var completed = false
}


			subscriber.disposable.addDisposable(selfDisposable)
		}
	}

	/// Concatenates each inner signal with the previous and next inner signals.
	///
	/// evidence - Used to prove to the typechecker that the receiver is
	///            a signal of signals. Simply pass in the `identity` function.
	///
	/// Returns a signal that will forward events from each of the original
	/// signals, in sequential order.
	public func concat<U>(evidence: ColdSignal -> ColdSignal<ColdSignal<U>>) -> ColdSignal<U> {
		return ColdSignal<U> { subscriber in
			var state = ConcatState<U>(subscriber: subscriber)

			let selfDisposable = evidence(self).start(next: { signal in
				// TODO: Avoid multiple dispatches.
				dispatch_sync(state.queue) {
					state.enqueuedSignals.append(signal)
				}

				state.dequeueIfReady()
			}, error: { error in
				subscriber.put(.Error(error))
			}, completed: {
				state.decrementInFlight()
			})

			subscriber.disposable.addDisposable(selfDisposable)
		}
	}

	/// Concatenates the given signal after the receiver.
	public func concat(signal: ColdSignal) -> ColdSignal {
		return ColdSignal<ColdSignal>.fromValues([ self, signal ])
			.concat(identity)
	}

	/// Ignores all values from the receiver, then subscribes to and forwards
