 
 extension SignalProtocol {
 
-    /// Propagate events only from a signal that starts emitting first.
+    /// Propagate events only from the signal that starts emitting first. Also known as the `race` operator.
+    ///
+    /// Check out interactive example: [https://rxmarbles.com/#race](https://rxmarbles.com/#race)
     public func amb<O: SignalProtocol>(with other: O) -> Signal<Element, Error> where O.Element == Element, O.Error == Error {
         return Signal { observer in
             let lock = NSRecursiveLock(name: "reactive_kit.amb")

        }
    }

    /// Merge emissions from both the receiver and the other signal into one signal.
    public func merge<O: SignalProtocol>(with other: O) -> Signal<Element, Error> where O.Element == Element, O.Error == Error {
        return Signal(sequence: [self.toSignal(), other.toSignal()]).merge()
    }

        }
    }

    /// Emit a pair of the latest elements from each signal. Starts when both signals emit at least one element.
    /// Emits a pair element when any of the two signals emit an element.
    ///
    /// Check out interactive example: [https://rxmarbles.com/#combineLatest](https://rxmarbles.com/#combineLatest)
    public func combineLatest<O: SignalProtocol>(with other: O) -> Signal<(Element, O.Element), Error> where O.Error == Error {
        return combineLatest(with: other, combine: { ($0, $1) })
    }

    /// First propagate all elements from the source signal and then all elements from the `other` signal.
    ///
    /// Check out interactive example: [https://rxmarbles.com/#concat](https://rxmarbles.com/#concat)
    public func concat<O: SignalProtocol>(with other: O) -> Signal<Element, Error> where O.Element == Element, O.Error == Error {
        return Signal { observer in
            let serialDisposable = SerialDisposable(otherDisposable: nil)
            serialDisposable.otherDisposable = self.observe { event in
