 extension SignalChannel {
 	
 	public func all(context: Exec = .direct, test: @escaping (T) -> Bool) -> SignalChannel<I, Bool> {
-		return nextStage { $0.all(context: context, test: test) }
+		return next { $0.all(context: context, test: test) }
 	}
 	
 	public func some(context: Exec = .direct, test: @escaping (T) -> Bool) -> SignalChannel<I, Bool> {
-		return nextStage { $0.some(context: context, test: test) }
+		return next { $0.some(context: context, test: test) }
 		}
 }
 
 extension SignalChannel where T: Equatable {
 	
 	public func contains(value: T) -> SignalChannel<I, Bool> {
-		return nextStage { $0.contains(value: value) }
+		return next { $0.contains(value: value) }
 	}
 }
 
 extension SignalChannel {
 	
 	public func defaultIfEmpty(value: T) -> SignalChannel<I, T> {
-		return nextStage { $0.defaultIfEmpty(value: value) }
+		return next { $0.defaultIfEmpty(value: value) }
 	}
 	
 	public func switchIfEmpty(alternate: Signal<T>) -> SignalChannel<I, T> {
-		return nextStage { $0.switchIfEmpty(alternate: alternate) }
+		return next { $0.switchIfEmpty(alternate: alternate) }
 		}
 }
 
 extension SignalChannel where T: Equatable {
 	
 	public func sequenceEqual(to: Signal<T>) -> SignalChannel<I, Bool> {
-		return nextStage { $0.sequenceEqual(to: to) }
+		return next { $0.sequenceEqual(to: to) }
 	}
 }
 
 extension SignalChannel {
 	
 	public func skipUntil<U>(_ other: Signal<U>) -> SignalChannel<I, T> {
-		return nextStage { $0.skipUntil(other) }
+		return next { $0.skipUntil(other) }
 	}
 	
 	public func skipWhile(context: Exec = .direct, condition: @escaping (T) -> Bool) -> SignalChannel<I, T> {
-		return nextStage { $0.skipWhile(context: context, condition: condition) }
+		return next { $0.skipWhile(context: context, condition: condition) }
 		}
 	
 	public func skipWhile<U>(initialState initial: U, context: Exec = .direct, condition: @escaping (inout U, T) -> Bool) -> SignalChannel<I, T> {
-		return nextStage { $0.skipWhile(initialState: initial, context: context, condition: condition) }
+		return next { $0.skipWhile(initialState: initial, context: context, condition: condition) }
 		}
 	
 	public func takeUntil<U>(_ other: Signal<U>) -> SignalChannel<I, T> {
-		return nextStage { $0.takeUntil(other) }
+		return next { $0.takeUntil(other) }
 		}
 	
 	public func takeWhile(context: Exec = .direct, condition: @escaping (T) -> Bool) -> SignalChannel<I, T> {
-		return nextStage { $0.takeWhile(context: context, condition: condition) }
+		return next { $0.takeWhile(context: context, condition: condition) }
 		}
 	
 	public func takeWhile<U>(initialState initial: U, context: Exec = .direct, condition: @escaping (inout U, T) -> Bool) -> SignalChannel<I, T> {
-		return nextStage { $0.takeWhile(initialState: initial, context: context, condition: condition) }
+		return next { $0.takeWhile(initialState: initial, context: context, condition: condition) }
 		}
 	
 	public func foldAndFinalize<U, V>(_ initial: V, context: Exec = .direct, finalize: @escaping (V) -> U?, fold: @escaping (V, T) -> V) -> SignalChannel<I, U> {
-		return nextStage { $0.foldAndFinalize(initial, context: context, finalize: finalize, fold: fold) }
+		return next { $0.foldAndFinalize(initial, context: context, finalize: finalize, fold: fold) }
 		}
 }
 
 extension SignalChannel where T: BinaryInteger {
 	
 	public func average() -> SignalChannel<I, T> {
-		return nextStage { $0.average() }
+		return next { $0.average() }
 	}
 }
 
 extension SignalChannel {
 	
 	public func concat(_ other: Signal<T>) -> SignalChannel<I, T> {
-		return nextStage { $0.concat(other) }
+		return next { $0.concat(other) }
 	}
 	
 	public func count() -> SignalChannel<I, Int> {
-		return nextStage { $0.count() }
+		return next { $0.count() }
 		}
 }
 
 extension SignalChannel where T: Comparable {
 	
 	public func min() -> SignalChannel<I, T> {
-		return nextStage { $0.min() }
+		return next { $0.min() }
 	}
 	
 	public func max() -> SignalChannel<I, T> {
-		return nextStage { $0.max() }
+		return next { $0.max() }
 		}
 }
 
 extension SignalChannel {
 	
 	public func reduce<U>(_ initial: U, context: Exec = .direct, fold: @escaping (U, T) -> U) -> SignalChannel<I, U> {
-		return nextStage { $0.reduce(initial, context: context, fold: fold) }
+		return next { $0.reduce(initial, context: context, fold: fold) }
 	}
 }
 
 extension SignalChannel where T: Numeric {
 	
 	public func sum() -> SignalChannel<I, T> {
-		return nextStage { $0.sum() }
+		return next { $0.sum() }
 	}
 }
 

extension SignalChannel {
	
	public func timeInterval(context: Exec = .direct) -> SignalChannel<I, Double> {
		return nextStage { $0.timeInterval(context: context) }
	}
	
	public func timeout(interval: DispatchTimeInterval, resetOnValue: Bool = true, context: Exec = .direct) -> SignalChannel<I, T> {
		return nextStage { $0.timeout(interval: interval, resetOnValue: resetOnValue, context: context) }
		}
	
	public func timestamp(context: Exec = .direct) -> SignalChannel<I, (T, DispatchTime)> {
		return nextStage { $0.timestamp(context: context) }
		}
}


		self.signal = signal
	}
	public init(_ tuple: (I, Signal<T>)) {
		self.init(input: tuple.0, signal: tuple.1)
	}
	public func next<U>(_ compose: (Signal<T>) throws -> Signal<U>) rethrows -> SignalChannel<I, U> {
		return try SignalChannel<I, U>(input: input, signal: compose(signal))
	}
	public func final<U>(_ compose: (Signal<T>) throws -> U) rethrows -> (I, U) {
		return try (input, compose(signal))
	}
	public var pair: (I, Signal<T>) { return (input, signal) }
}

func channel<T>() -> SignalChannel<SignalInput<T>, T> {
	return SignalChannel<SignalInput<T>, T>(Signal<T>.create())
}

extension Signal {
