 			}
 			.merge(identity)
 	}
-
-	/// Ignores all values from the receiver, then subscribes to and forwards
-	/// events from the given signal once the receiver has completed.
-	public func then<U>(signal: ColdSignal<U>) -> ColdSignal<U> {
-		return ColdSignal<U> { subscriber in
-			let disposable = SerialDisposable()
-			subscriber.disposable.addDisposable(disposable)
-
-			disposable.innerDisposable = self.subscribe(error: { error in
-				subscriber.put(.Error(error))
-			}, completed: {
-				disposable.innerDisposable = signal.subscribe(subscriber)
-			})
-		}
-	}
-
+}
+
+/// Methods for combining multiple signals.
+extension ColdSignal {
 	private func subscribeWithStates<U>(selfState: CombineLatestState<T>, _ otherState: CombineLatestState<U>, queue: dispatch_queue_t, onBothNext: () -> (), onError: NSError -> (), onBothCompleted: () -> ()) -> Disposable {
 		return subscribe(next: { value in
 			dispatch_sync(queue) {

		self.generator = generator
	}

	/// Creates a signal that will execute the given action upon subscription,
	/// then forward all events from the generated signal.
	public static func defer(action: () -> ColdSignal) -> ColdSignal {
		return ColdSignal { subscriber in
			action().subscribe(subscriber)
			return ()
		}
	}

	/// Creates a signal that will immediately complete.
	public static func empty() -> ColdSignal {
		return ColdSignal { subscriber in
			subscriber.put(.Completed)
		}
	}

	/// Creates a signal that will immediately yield a single value then
	/// complete.
	public static func single(value: T) -> ColdSignal {
		return ColdSignal { subscriber in
			subscriber.put(.Next(Box(value)))
			subscriber.put(.Completed)
		}
	}

	/// Creates a signal that will immediately generate an error.
	public static func error(error: NSError) -> ColdSignal {
		return ColdSignal { subscriber in
			subscriber.put(.Error(error))
		}
	}

	/// Creates a signal that will iterate over the given sequence whenever a
	/// Subscriber is attached.
	///
	/// If the signal will be consumed multiple times, the given sequence must
	/// be multi-pass (i.e., support obtaining and using multiple generators).
	public static func fromValues<S: SequenceType where S.Generator.Element == T>(values: S) -> ColdSignal {
		return ColdSignal { subscriber in
			var generator = values.generate()

			while let value: T = generator.next() {
				subscriber.put(.Next(Box(value)))
			}

			subscriber.put(.Completed)
		}
	}

	/// Creates a signal that will never send any events.
	public static func never() -> ColdSignal {
		return ColdSignal { _ in () }
	}

	/// Starts producing events for the given subscriber, performing any side
	/// effects embedded within the ColdSignal.
	///

	public func subscribe(next: T -> () = doNothing, error: NSError -> () = doNothing, completed: () -> () = doNothing) -> Disposable {
		return subscribe(Subscriber(next: next, error: error, completed: completed))
	}
}

/// Convenience constructors.
extension ColdSignal {
	/// Creates a signal that will execute the given action upon subscription,
	/// then forward all events from the generated signal.
	public static func defer(action: () -> ColdSignal) -> ColdSignal {
		return ColdSignal { subscriber in
			action().subscribe(subscriber)
			return ()
		}
	}

	/// Creates a signal that will immediately complete.
	public static func empty() -> ColdSignal {
		return ColdSignal { subscriber in
			subscriber.put(.Completed)
		}
	}

	/// Creates a signal that will immediately yield a single value then
	/// complete.
	public static func single(value: T) -> ColdSignal {
		return ColdSignal { subscriber in
			subscriber.put(.Next(Box(value)))
			subscriber.put(.Completed)
		}
	}

	/// Creates a signal that will immediately generate an error.
	public static func error(error: NSError) -> ColdSignal {
		return ColdSignal { subscriber in
			subscriber.put(.Error(error))
		}
	}

	/// Creates a signal that will never send any events.
	public static func never() -> ColdSignal {
		return ColdSignal { _ in () }
	}

	/// Creates a signal that will iterate over the given sequence whenever a
	/// Subscriber is attached.
	///
	/// If the signal will be consumed multiple times, the given sequence must
	/// be multi-pass (i.e., support obtaining and using multiple generators).
	public static func fromValues<S: SequenceType where S.Generator.Element == T>(values: S) -> ColdSignal {
		return ColdSignal { subscriber in
			var generator = values.generate()

			while let value: T = generator.next() {
				subscriber.put(.Next(Box(value)))
			}

			subscriber.put(.Completed)
		}
	}
}

/// Transformative operators.
extension ColdSignal {
	/// Maps over the elements of the signal, accumulating a state along the
	/// way.
	///
