 /// Forwards only those values from `signal` which are not duplicates of the
 /// immedately preceding value. The first value is always forwarded.
 public func skipRepeats<T: Equatable, E>(signal: Signal<T, E>) -> Signal<T, E> {
-	return signal |> skipRepeats { $0 == $1 }
+	return signal.skipRepeats()
+}
+
+extension SignalType where T: Equatable {
+	public func skipRepeats() -> Signal<T, E> {
+		return skipRepeats { $0 == $1 }
+	}
 }
 
 /// Forwards only those values from `signal` which do not pass `isRepeat` with
 /// respect to the previous value. The first value is always forwarded.
 public func skipRepeats<T, E>(isRepeat: (T, T) -> Bool) -> Signal<T, E> -> Signal<T, E> {
-	return { signal in
+	return { $0.skipRepeats(isRepeat) }
+}
+
+extension SignalType {
+	public func skipRepeats(isRepeat: (T, T) -> Bool) -> Signal<T, E> {
 		return signal
-			|> map { Optional($0) }
-			|> combinePrevious(nil)
-			|> filter { (a, b) in
+			.map { Optional($0) }
+			.combinePrevious(nil)
+			.filter { (a, b) in
 				if let a = a, b = b where isRepeat(a, b) {
 					return false
 				} else {
 					return true
 				}
 			}
-			|> map { $0.1! }
+			.map { $0.1! }
 	}
 }
 
 /// Does not forward any values from `signal` until `predicate` returns false,
 /// at which point the returned signal behaves exactly like `signal`.
 public func skipWhile<T, E>(predicate: T -> Bool) -> Signal<T, E> -> Signal<T, E> {
-	return { signal in
+	return { $0.skipWhile(predicate) }
+}
+
+extension SignalType {
+	public func skipWhile(predicate: T -> Bool) -> Signal<T, E> {
 		return Signal { observer in
 			var shouldSkip = true
 
-			return signal.observe { event in
+			return self.signal.observe { event in
 				switch event {
 				case let .Next(value):
 					shouldSkip = shouldSkip && predicate(value)

/// Applies `operation` to values from `signal` with `Success`ful results mapped
/// on the returned signal and `Failure`s sent as `Error` events.
public func attemptMap<T, U, E>(operation: T -> Result<U, E>) -> Signal<T, E> -> Signal<U, E> {
	return { signal in
		return Signal { observer in
			signal.observe(next: { value in
				operation(value).analysis(ifSuccess: { value in
					sendNext(observer, value)
				}, ifFailure: { error in

/// the Event itself and then complete. When an Interrupted event is received,
/// the resulting signal will send the Event itself and then interrupt.
public func materialize<T, E>(signal: Signal<T, E>) -> Signal<Event<T, E>, NoError> {
	return signal.materialize()
}

extension SignalType {
	public func materialize() -> Signal<Event<T, E>, NoError> {
		return Signal { observer in
			return self.signal.observe { event in
				sendNext(observer, event)

				switch event {
				case .Interrupted:
					sendInterrupted(observer)

				case .Completed, .Error:
					sendCompleted(observer)

				case .Next:
					break
				}
			}
		}
	}
