      */
     public static func merge(_ sources: Observable<E>...) -> Observable<E> {
         return MergeArray(sources: sources)
+    }
+}
+
+// MARK: concatMap
+
+extension ObservableType {
+    /**
+     Projects each element of an observable sequence to an observable sequence and concatenates the resulting observable sequences into one observable sequence.
+     
+     - seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
+     
+     - returns: An observable sequence that contains the elements of each observed inner sequence, in sequential order.
+     */
+    
+    public func concatMap<O: ObservableConvertibleType>(_ selector: @escaping (E) throws -> O)
+        -> Observable<O.E> {
+            return ConcatMap(source: asObservable(), selector: selector)
     }
 }
 

    }
}

fileprivate final class MapConcatSink<SourceType, S: ObservableConvertibleType, O: ObserverType>: MergeLimitedSink<SourceType, S, O> where O.E == S.E {
    typealias Selector = (SourceType) throws -> S
    
    private let _selector: Selector

    }
    
    override func run<O: ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == S.E {
        let sink = ConcatMapSink<SourceType, S, O>(selector: _selector, observer: observer, cancel: cancel)
        let subscription = sink.run(_source)
        return (sink: sink, subscription: subscription)
    }
