 		})
 
 		if !signalDisposable.disposed {
-			signalDisposable.innerDisposable = signal
-				|> concat(Signal.never)
-				|> observe(observer)
-		}
-
-		return CompositeDisposable([signalDisposable, replacementDisposable])
-    }
+			signalDisposable.innerDisposable = signal.observe(next: { value in
+				sendNext(observer, value)
+			}, error: { error in
+				sendError(observer, error)
+			})
+		}
+
+		return CompositeDisposable([ signalDisposable, replacementDisposable ])
+	}
 }
 
 /*

/// send that event and switch to passing through events from `replacement`
/// instead, regardless of whether `signal` has sent events already.
public func takeUntilReplacement<T, E>(replacement: Signal<T, E>)(signal: Signal<T, E>) -> Signal<T, E> {
    return Signal { observer in
		let signalDisposable = SerialDisposable()

        let replacementDisposable = replacement.observe(next: { value in
			signalDisposable.dispose()
			sendNext(observer, value)
		}, error: { error in

	}
}

/// Forwards events from `signal` until `replacement` begins sending events.
///
/// Returns a signal which passes through `next`s and `error` from `signal`
