change the implementation to emit only on completion.

Author: jdisho

Playground/RxSwiftExtPlayground.playground/Pages/toSortedArray.xcplaygroundpage/Contents.swift

@@ -18,22 +18,27 @@ import RxSwiftExt
  */
 
 example("Ensure that only a sorted array is emitted") {
-    let array1 = Observable.of([5, 4, 7, 8, 2, 6, 9, 0, 10])
-    let array2 = Observable.of([10, 9, 12, 8, 4, 1, 1, 8, 14])
-    
-    array1.toSortedArray()
+    let sequenceStream = Observable.of(1...12)
+    let array = Observable.of([10, 9, 12, 8, 4, 1, 1, 8, 14])
+
+    // Ascending order
+    array.toSortedArray()
         .subscribe(onNext: { result in
             print(result)
         })
 
-    // Ascending order
-    array2.toSortedArray(<)
+    array.toSortedArray(<)
         .subscribe(onNext: { result in
             print(result)
         })
 
     // Descending order
-    array2.toSortedArray(>)
+    sequenceStream.toSortedArray(>)
+        .subscribe(onNext: { result in
+            print(result)
+        })
+
+    array.toSortedArray(>)
         .subscribe(onNext: { result in
             print(result)
         })

Source/RxSwift/toSortedArray.swift

@@ -17,19 +17,22 @@ extension Observable where E: Sequence, E.Element: Comparable {
      - returns: The sorted observable.
     */
     public func toSortedArray<T>(ascending: Bool = true)
-        -> Observable<[T]> where E.Iterator.Element == T {
-        return map {
-            $0.sorted(by: { ascending ? $0 < $1 : $0 > $1 })
-        }
+        -> Observable<[T]> where E.Element == T {
+        return toSortedArray({ ascending ? $0 < $1 : $0 > $1 })
     }
+
     /**
      Transforms an observable of comparables into an observable of ordered arrays by using the function passed in.
 
      - parameter areInIncreasingOrder: A function to compare to elements.
      - returns: The sorted observable.
      */
     public func toSortedArray<T>(_ areInIncreasingOrder: @escaping (T, T) -> Bool)
-        -> Observable<[T]> where E.Iterator.Element == T {
-        return map { $0.sorted(by: areInIncreasingOrder) }
+        -> Observable<[T]> where E.Element == T {
+            return toArray().map { elements in
+                elements.flatMap { element in
+                    element.sorted(by: areInIncreasingOrder)
+                }
+            }
     }
 }