Infallible WIP

Rx.xcodeproj/project.pbxproj

@@ -50,6 +50,13 @@
 		6A7D2CD523BBDBDC0038576E /* ReplayRelayTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6A7D2CD323BBDBDC0038576E /* ReplayRelayTests.swift */; };
 		6A7D2CD623BBDBDC0038576E /* ReplayRelayTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6A7D2CD323BBDBDC0038576E /* ReplayRelayTests.swift */; };
 		6A94254A23AFC2F300B7A24C /* ReplayRelay.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6A94254923AFC2F300B7A24C /* ReplayRelay.swift */; };
+		7846F56624F83AF400A39919 /* Infallible.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7846F56524F83AF400A39919 /* Infallible.swift */; };
+		786DED6324F83DE5008C4FAC /* ObservableConvertibleType+Infallible.swift in Sources */ = {isa = PBXBuildFile; fileRef = 786DED6224F83DE5008C4FAC /* ObservableConvertibleType+Infallible.swift */; };
+		786DED6924F8415B008C4FAC /* Infallible+Zip+arity.swift in Sources */ = {isa = PBXBuildFile; fileRef = 786DED6824F8415B008C4FAC /* Infallible+Zip+arity.swift */; };
+		786DED6C24F844BC008C4FAC /* Infallible+CombineLatest+arity.swift in Sources */ = {isa = PBXBuildFile; fileRef = 786DED6B24F844BC008C4FAC /* Infallible+CombineLatest+arity.swift */; };
+		786DED6E24F84623008C4FAC /* Infallible+Operators.swift in Sources */ = {isa = PBXBuildFile; fileRef = 786DED6D24F84623008C4FAC /* Infallible+Operators.swift */; };
+		786DED7024F847BF008C4FAC /* Infallible+Create.swift in Sources */ = {isa = PBXBuildFile; fileRef = 786DED6F24F847BF008C4FAC /* Infallible+Create.swift */; };
+		786DED7224F849F3008C4FAC /* Infallible+Bind.swift in Sources */ = {isa = PBXBuildFile; fileRef = 786DED7124F849F3008C4FAC /* Infallible+Bind.swift */; };
 		788DCE5D24CB8249005B8F8C /* Decode.swift in Sources */ = {isa = PBXBuildFile; fileRef = 788DCE5C24CB8249005B8F8C /* Decode.swift */; };
 		788DCE5F24CB8512005B8F8C /* Observable+DecodeTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 788DCE5E24CB8512005B8F8C /* Observable+DecodeTests.swift */; };
 		788DCE6024CB8512005B8F8C /* Observable+DecodeTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 788DCE5E24CB8512005B8F8C /* Observable+DecodeTests.swift */; };
@@ -951,6 +958,15 @@
 		601AE3D91EE24E4F00617386 /* SwiftSupport.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SwiftSupport.swift; sourceTree = "<group>"; };
 		6A7D2CD323BBDBDC0038576E /* ReplayRelayTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ReplayRelayTests.swift; sourceTree = "<group>"; };
 		6A94254923AFC2F300B7A24C /* ReplayRelay.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ReplayRelay.swift; sourceTree = "<group>"; };
+		7846F56524F83AF400A39919 /* Infallible.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Infallible.swift; sourceTree = "<group>"; };
+		786DED6224F83DE5008C4FAC /* ObservableConvertibleType+Infallible.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "ObservableConvertibleType+Infallible.swift"; sourceTree = "<group>"; };
+		786DED6624F84095008C4FAC /* Infallible+Zip+arity.tt */ = {isa = PBXFileReference; lastKnownFileType = text; path = "Infallible+Zip+arity.tt"; sourceTree = "<group>"; };
+		786DED6824F8415B008C4FAC /* Infallible+Zip+arity.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Infallible+Zip+arity.swift"; sourceTree = "<group>"; };
+		786DED6A24F84432008C4FAC /* Infallible+CombineLatest+arity.tt */ = {isa = PBXFileReference; lastKnownFileType = text; path = "Infallible+CombineLatest+arity.tt"; sourceTree = "<group>"; };
+		786DED6B24F844BC008C4FAC /* Infallible+CombineLatest+arity.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Infallible+CombineLatest+arity.swift"; sourceTree = "<group>"; };
+		786DED6D24F84623008C4FAC /* Infallible+Operators.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Infallible+Operators.swift"; sourceTree = "<group>"; };
+		786DED6F24F847BF008C4FAC /* Infallible+Create.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Infallible+Create.swift"; sourceTree = "<group>"; };
+		786DED7124F849F3008C4FAC /* Infallible+Bind.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Infallible+Bind.swift"; sourceTree = "<group>"; };
 		788DCE5C24CB8249005B8F8C /* Decode.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Decode.swift; sourceTree = "<group>"; };
 		788DCE5E24CB8512005B8F8C /* Observable+DecodeTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Observable+DecodeTests.swift"; sourceTree = "<group>"; };
 		78B6157623B6A035009C2AD9 /* Binder+Tests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Binder+Tests.swift"; sourceTree = "<group>"; };
@@ -1524,6 +1540,36 @@
 			path = SwiftSupport;
 			sourceTree = "<group>";
 		};
+		786DED6424F83F37008C4FAC /* PrimitiveSequence */ = {
+			isa = PBXGroup;
+			children = (
+				C81A09861E6C702700900B3B /* PrimitiveSequence.swift */,
+				25F6ECBF1F48C37C008552FA /* Single.swift */,
+				25F6ECBB1F48C366008552FA /* Maybe.swift */,
+				25F6ECBD1F48C373008552FA /* Completable.swift */,
+				C89814751E75A18A0035949C /* PrimitiveSequence+Zip+arity.tt */,
+				C89814771E75A7D70035949C /* PrimitiveSequence+Zip+arity.swift */,
+				C8A53ADF1F09178700490535 /* Completable+AndThen.swift */,
+				C801DE411F6EBB29008DB060 /* ObservableType+PrimitiveSequence.swift */,
+			);
+			path = PrimitiveSequence;
+			sourceTree = "<group>";
+		};
+		786DED6524F83F49008C4FAC /* Infallible */ = {
+			isa = PBXGroup;
+			children = (
+				7846F56524F83AF400A39919 /* Infallible.swift */,
+				786DED6224F83DE5008C4FAC /* ObservableConvertibleType+Infallible.swift */,
+				786DED6824F8415B008C4FAC /* Infallible+Zip+arity.swift */,
+				786DED6624F84095008C4FAC /* Infallible+Zip+arity.tt */,
+				786DED6A24F84432008C4FAC /* Infallible+CombineLatest+arity.tt */,
+				786DED6B24F844BC008C4FAC /* Infallible+CombineLatest+arity.swift */,
+				786DED6D24F84623008C4FAC /* Infallible+Operators.swift */,
+				786DED6F24F847BF008C4FAC /* Infallible+Create.swift */,
+			);
+			path = Infallible;
+			sourceTree = "<group>";
+		};
 		A2897CB2225CA1C6004EA481 /* RxRelay */ = {
 			isa = PBXGroup;
 			children = (
@@ -1757,6 +1803,7 @@
 			isa = PBXGroup;
 			children = (
 				C80D338E1B91EF9E0014629D /* Observable+Bind.swift */,
+				786DED7124F849F3008C4FAC /* Infallible+Bind.swift */,
 				C8093E8B1B8A732E0088E94D /* DelegateProxy.swift */,
 				C8093E8C1B8A732E0088E94D /* DelegateProxyType.swift */,
 				C8093E9C1B8A732E0088E94D /* RxTarget.swift */,
@@ -1787,14 +1834,8 @@
 		C81A09851E6C701700900B3B /* Traits */ = {
 			isa = PBXGroup;
 			children = (
-				C81A09861E6C702700900B3B /* PrimitiveSequence.swift */,
-				25F6ECBF1F48C37C008552FA /* Single.swift */,
-				25F6ECBB1F48C366008552FA /* Maybe.swift */,
-				25F6ECBD1F48C373008552FA /* Completable.swift */,
-				C89814751E75A18A0035949C /* PrimitiveSequence+Zip+arity.tt */,
-				C89814771E75A7D70035949C /* PrimitiveSequence+Zip+arity.swift */,
-				C8A53ADF1F09178700490535 /* Completable+AndThen.swift */,
-				C801DE411F6EBB29008DB060 /* ObservableType+PrimitiveSequence.swift */,
+				786DED6524F83F49008C4FAC /* Infallible */,
+				786DED6424F83F37008C4FAC /* PrimitiveSequence */,
 			);
 			path = Traits;
 			sourceTree = "<group>";
@@ -2954,6 +2995,7 @@
 				A520FFFC1F0D291500573734 /* RxPickerViewDataSourceProxy.swift in Sources */,
 				C882542A1B8A752B00B02D69 /* UIControl+Rx.swift in Sources */,
 				C8D132441C42D15E00B59FFF /* SectionedViewDataSourceType.swift in Sources */,
+				786DED7224F849F3008C4FAC /* Infallible+Bind.swift in Sources */,
 				B562478F203515DD00D3EE75 /* RxCollectionViewDataSourcePrefetchingProxy.swift in Sources */,
 				84E4D3921C9AFD3400ADFDC9 /* UISearchController+Rx.swift in Sources */,
 				C88254341B8A752B00B02D69 /* UITableView+Rx.swift in Sources */,
@@ -3616,6 +3658,7 @@
 				C820A8481EB4DA5900D431BC /* Skip.swift in Sources */,
 				C820A8D81EB4DA5A00D431BC /* Using.swift in Sources */,
 				C8165ACB21891BBF00494BEF /* AtomicInt.swift in Sources */,
+				786DED6E24F84623008C4FAC /* Infallible+Operators.swift in Sources */,
 				C8550B4B1D95A41400A6FCFE /* Reactive.swift in Sources */,
 				CB883B451BE256D4000AC2EE /* BooleanDisposable.swift in Sources */,
 				C820A9241EB4DA5A00D431BC /* CombineLatest.swift in Sources */,
@@ -3624,6 +3667,7 @@
 				C820A9201EB4DA5A00D431BC /* AddRef.swift in Sources */,
 				C820A9081EB4DA5A00D431BC /* Multicast.swift in Sources */,
 				C8093DA31B8A72BE0088E94D /* ReplaySubject.swift in Sources */,
+				786DED6924F8415B008C4FAC /* Infallible+Zip+arity.swift in Sources */,
 				C8093CFB1B8A72BE0088E94D /* ObservableType+Extensions.swift in Sources */,
 				4C5213AA225D41E60079FC77 /* CompactMap.swift in Sources */,
 				C820A8781EB4DA5A00D431BC /* TakeLast.swift in Sources */,
@@ -3648,10 +3692,12 @@
 				C820A8F41EB4DA5A00D431BC /* Create.swift in Sources */,
 				C820A8901EB4DA5A00D431BC /* Scan.swift in Sources */,
 				CB883B401BE24C15000AC2EE /* RefCountDisposable.swift in Sources */,
+				7846F56624F83AF400A39919 /* Infallible.swift in Sources */,
 				C84CC54E1BDCF48200E06A64 /* LockOwnerType.swift in Sources */,
 				C8FA89151C30405400CD3A17 /* VirtualTimeScheduler.swift in Sources */,
 				C84CC5531BDCF49300E06A64 /* SynchronizedOnType.swift in Sources */,
 				C820A8601EB4DA5A00D431BC /* Generate.swift in Sources */,
+				786DED7024F847BF008C4FAC /* Infallible+Create.swift in Sources */,
 				78B6157523B69F49009C2AD9 /* Binder.swift in Sources */,
 				C8C3DA0F1B939767004D233E /* CurrentThreadScheduler.swift in Sources */,
 				C8093D851B8A72BE0088E94D /* Rx.swift in Sources */,
@@ -3679,6 +3725,7 @@
 				C820A93C1EB4DA5A00D431BC /* Zip+arity.swift in Sources */,
 				C8093D971B8A72BE0088E94D /* RecursiveScheduler.swift in Sources */,
 				C8093CDF1B8A72BE0088E94D /* DisposeBase.swift in Sources */,
+				786DED6C24F844BC008C4FAC /* Infallible+CombineLatest+arity.swift in Sources */,
 				C820A8C81EB4DA5A00D431BC /* Debug.swift in Sources */,
 				C820A8F81EB4DA5A00D431BC /* SubscribeOn.swift in Sources */,
 				C8093CD51B8A72BE0088E94D /* AnonymousDisposable.swift in Sources */,
@@ -3707,6 +3754,7 @@
 				C820A8AC1EB4DA5A00D431BC /* Amb.swift in Sources */,
 				C820A8541EB4DA5900D431BC /* Sample.swift in Sources */,
 				C8845AD41EDB4C9900B36836 /* ShareReplayScope.swift in Sources */,
+				786DED6324F83DE5008C4FAC /* ObservableConvertibleType+Infallible.swift in Sources */,
 				C86781701DB8129E00B2029A /* Bag.swift in Sources */,
 				C8093CF71B8A72BE0088E94D /* ImmediateSchedulerType.swift in Sources */,
 				C8BF34CB1C2E426800416CAE /* Platform.Darwin.swift in Sources */,

RxCocoa/Common/Infallible+Bind.swift

@@ -0,0 +1,76 @@
+//
+//  Infallible+Bind.swift
+//  RxCocoa
+//
+//  Created by Shai Mishali on 27/08/2020.
+//  Copyright © 2020 Krunoslav Zaher. All rights reserved.
+//
+
+import RxSwift
+
+extension InfallibleType {
+    /**
+     Creates new subscription and sends elements to observer(s).
+     In this form, it's equivalent to the `subscribe` method, but it better conveys intent, and enables
+     writing more consistent binding code.
+     - parameter to: Observers to receives events.
+     - returns: Disposable object that can be used to unsubscribe the observers.
+     */
+    public func bind<Observer: ObserverType>(to observers: Observer...) -> Disposable where Observer.Element == Element {
+        self.subscribe { event in
+            observers.forEach { $0.on(event) }
+        }
+    }
+
+    /**
+     Creates new subscription and sends elements to observer(s).
+     In this form, it's equivalent to the `subscribe` method, but it better conveys intent, and enables
+     writing more consistent binding code.
+     - parameter to: Observers to receives events.
+     - returns: Disposable object that can be used to unsubscribe the observers.
+     */
+    public func bind<Observer: ObserverType>(to observers: Observer...) -> Disposable where Observer.Element == Element? {
+        self.map { $0 as Element? }
+            .subscribe { event in
+                observers.forEach { $0.on(event) }
+            }
+    }
+
+    /**
+    Subscribes to observable sequence using custom binder function.
+
+    - parameter to: Function used to bind elements from `self`.
+    - returns: Object representing subscription.
+    */
+    public func bind<Result>(to binder: (Self) -> Result) -> Result {
+        binder(self)
+    }
+
+    /**
+    Subscribes to observable sequence using custom binder function and final parameter passed to binder function
+    after `self` is passed.
+
+        public func bind<R1, R2>(to binder: Self -> R1 -> R2, curriedArgument: R1) -> R2 {
+            return binder(self)(curriedArgument)
+        }
+
+    - parameter to: Function used to bind elements from `self`.
+    - parameter curriedArgument: Final argument passed to `binder` to finish binding process.
+    - returns: Object representing subscription.
+    */
+    public func bind<R1, R2>(to binder: (Self) -> (R1) -> R2, curriedArgument: R1) -> R2 {
+        binder(self)(curriedArgument)
+    }
+
+    /**
+    Subscribes an element handler to an observable sequence.
+    In case error occurs in debug mode, `fatalError` will be raised.
+    In case error occurs in release mode, `error` will be logged.
+
+    - parameter onNext: Action to invoke for each element in the observable sequence.
+    - returns: Subscription object used to unsubscribe from the observable sequence.
+    */
+    public func bind(onNext: @escaping (Element) -> Void) -> Disposable {
+        self.subscribe(onNext: onNext)
+    }
+}

RxCocoa/Common/Observable+Bind.swift

@@ -17,9 +17,9 @@ extension ObservableType {
      - returns: Disposable object that can be used to unsubscribe the observers.
      */
     public func bind<Observer: ObserverType>(to observers: Observer...) -> Disposable where Observer.Element == Element {
-        return self.subscribe { event in
-                       observers.forEach { $0.on(event) }
-                   }
+        self.subscribe { event in
+            observers.forEach { $0.on(event) }
+        }
     }
 
     /**
@@ -30,10 +30,10 @@ extension ObservableType {
      - returns: Disposable object that can be used to unsubscribe the observers.
      */
     public func bind<Observer: ObserverType>(to observers: Observer...) -> Disposable where Observer.Element == Element? {
-        return self.map { $0 as Element? }
-                   .subscribe { event in
-                       observers.forEach { $0.on(event) }
-                   }
+        self.map { $0 as Element? }
+            .subscribe { event in
+                observers.forEach { $0.on(event) }
+            }
     }
 
     /**
@@ -59,10 +59,9 @@ extension ObservableType {
     - returns: Object representing subscription.
     */
     public func bind<R1, R2>(to binder: (Self) -> (R1) -> R2, curriedArgument: R1) -> R2 {
-         return binder(self)(curriedArgument)
+        binder(self)(curriedArgument)
     }
 
-
     /**
     Subscribes an element handler to an observable sequence.
     In case error occurs in debug mode, `fatalError` will be raised.
@@ -72,8 +71,9 @@ extension ObservableType {
     - returns: Subscription object used to unsubscribe from the observable sequence.
     */
     public func bind(onNext: @escaping (Element) -> Void) -> Disposable {
-        return self.subscribe(onNext: onNext, onError: { error in
-            rxFatalErrorInDebug("Binding error: \(error)")
-        })
+        self.subscribe(onNext: onNext,
+                       onError: { error in
+                        rxFatalErrorInDebug("Binding error: \(error)")
+                       })
     }
 }

RxCocoa/Traits/SharedSequence/SharedSequence+Operators+arity.tt

@@ -20,7 +20,7 @@ extension SharedSequence {
     - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
     */
     public static func zip<<%= (Array(1...i).map { "O\($0): SharedSequenceConvertibleType" }).joined(separator: ", ") %>>
-        (<%= (Array(1...i).map { "_ source\($0): O\($0)" }).joined(separator: ", ") %>, resultSelector: @escaping (<%= (Array(1...i).map { "O\($0).E" }).joined(separator: ", ") %>) throws -> Element)
+        (<%= (Array(1...i).map { "_ source\($0): O\($0)" }).joined(separator: ", ") %>, resultSelector: @escaping (<%= (Array(1...i).map { "O\($0).Element" }).joined(separator: ", ") %>) throws -> Element)
         -> SharedSequence<O1.SharingStrategy, Element> where <%= (Array(1...i).map { "SharingStrategy == O\($0).SharingStrategy" }).joined(separator: ",\n            ") %> {
         let source = Observable.zip(
             <%= (Array(1...i).map { "source\($0).asSharedSequence().asObservable()" }).joined(separator: ", ") %>,
@@ -39,12 +39,12 @@ extension SharedSequenceConvertibleType where Element == Any {
     */
     public static func zip<<%= (Array(1...i).map { "O\($0): SharedSequenceConvertibleType" }).joined(separator: ", ") %>>
         (<%= (Array(1...i).map { "_ source\($0): O\($0)" }).joined(separator: ", ") %>)
-        -> SharedSequence<O1.SharingStrategy, (<%= (Array(1...i).map { "O\($0).E" }).joined(separator: ", ") %>)> where <%= (Array(1...i).map { "SharingStrategy == O\($0).SharingStrategy" }).joined(separator: ",\n            ") %> {
+        -> SharedSequence<O1.SharingStrategy, (<%= (Array(1...i).map { "O\($0).Element" }).joined(separator: ", ") %>)> where <%= (Array(1...i).map { "SharingStrategy == O\($0).SharingStrategy" }).joined(separator: ",\n            ") %> {
         let source = Observable.zip(
             <%= (Array(1...i).map { "source\($0).asSharedSequence().asObservable()" }).joined(separator: ", ") %>
         )
 
-        return SharedSequence<SharingStrategy, (<%= (Array(1...i).map { "O\($0).E" }).joined(separator: ", ") %>)>(source)
+        return SharedSequence<SharingStrategy, (<%= (Array(1...i).map { "O\($0).Element" }).joined(separator: ", ") %>)>(source)
     }
 }
 
@@ -56,7 +56,7 @@ extension SharedSequence {
     - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
     */
     public static func combineLatest<<%= (Array(1...i).map { "O\($0): SharedSequenceConvertibleType" }).joined(separator: ", ") %>>
-        (<%= (Array(1...i).map { "_ source\($0): O\($0)" }).joined(separator: ", ") %>, resultSelector: @escaping (<%= (Array(1...i).map { "O\($0).E" }).joined(separator: ", ") %>) throws -> Element)
+        (<%= (Array(1...i).map { "_ source\($0): O\($0)" }).joined(separator: ", ") %>, resultSelector: @escaping (<%= (Array(1...i).map { "O\($0).Element" }).joined(separator: ", ") %>) throws -> Element)
         -> SharedSequence<SharingStrategy, Element> where <%= (Array(1...i).map { "SharingStrategy == O\($0).SharingStrategy" }).joined(separator: ",\n            ") %> {
         let source = Observable.combineLatest(
                 <%= (Array(1...i).map { "source\($0).asSharedSequence().asObservable()" }).joined(separator: ", ") %>,
@@ -75,12 +75,12 @@ extension SharedSequenceConvertibleType where Element == Any {
     */
     public static func combineLatest<<%= (Array(1...i).map { "O\($0): SharedSequenceConvertibleType" }).joined(separator: ", ") %>>
         (<%= (Array(1...i).map { "_ source\($0): O\($0)" }).joined(separator: ", ") %>)
-        -> SharedSequence<SharingStrategy, (<%= (Array(1...i).map { "O\($0).E" }).joined(separator: ", ") %>)> where <%= (Array(1...i).map { "SharingStrategy == O\($0).SharingStrategy" }).joined(separator: ",\n            ") %> {
+        -> SharedSequence<SharingStrategy, (<%= (Array(1...i).map { "O\($0).Element" }).joined(separator: ", ") %>)> where <%= (Array(1...i).map { "SharingStrategy == O\($0).SharingStrategy" }).joined(separator: ",\n            ") %> {
         let source = Observable.combineLatest(
                 <%= (Array(1...i).map { "source\($0).asSharedSequence().asObservable()" }).joined(separator: ", ") %>
             )
 
-        return SharedSequence<O1.SharingStrategy, (<%= (Array(1...i).map { "O\($0).E" }).joined(separator: ", ") %>)>(source)
+        return SharedSequence<O1.SharingStrategy, (<%= (Array(1...i).map { "O\($0).Element" }).joined(separator: ", ") %>)>(source)
     }
 }
 

RxSwift/Observables/CombineLatest+arity.swift

@@ -78,7 +78,7 @@ final class CombineLatestSink2_<E1, E2, Observer: ObserverType> : CombineLatestS
         ])
     }
 
-    override func getResult() throws-> Result {
+    override func getResult() throws -> Result {
         try self.parent.resultSelector(self.latestElement1, self.latestElement2)
     }
 }
@@ -181,13 +181,13 @@ final class CombineLatestSink3_<E1, E2, E3, Observer: ObserverType> : CombineLat
         ])
     }
 
-    override func getResult() throws-> Result {
+    override func getResult() throws -> Result {
         try self.parent.resultSelector(self.latestElement1, self.latestElement2, self.latestElement3)
     }
 }
 
 final class CombineLatest3<E1, E2, E3, Result> : Producer<Result> {
-    typealias ResultSelector = (E1, E2, E3) throws-> Result
+    typealias ResultSelector = (E1, E2, E3) throws -> Result
 
     let source1: Observable<E1>
     let source2: Observable<E2>
@@ -291,13 +291,13 @@ final class CombineLatestSink4_<E1, E2, E3, E4, Observer: ObserverType> : Combin
         ])
     }
 
-    override func getResult() throws-> Result {
+    override func getResult() throws -> Result {
         try self.parent.resultSelector(self.latestElement1, self.latestElement2, self.latestElement3, self.latestElement4)
     }
 }
 
 final class CombineLatest4<E1, E2, E3, E4, Result> : Producer<Result> {
-    typealias ResultSelector = (E1, E2, E3, E4) throws-> Result
+    typealias ResultSelector = (E1, E2, E3, E4) throws -> Result
 
     let source1: Observable<E1>
     let source2: Observable<E2>
@@ -408,13 +408,13 @@ final class CombineLatestSink5_<E1, E2, E3, E4, E5, Observer: ObserverType> : Co
         ])
     }
 
-    override func getResult() throws-> Result {
+    override func getResult() throws -> Result {
         try self.parent.resultSelector(self.latestElement1, self.latestElement2, self.latestElement3, self.latestElement4, self.latestElement5)
     }
 }
 
 final class CombineLatest5<E1, E2, E3, E4, E5, Result> : Producer<Result> {
-    typealias ResultSelector = (E1, E2, E3, E4, E5) throws-> Result
+    typealias ResultSelector = (E1, E2, E3, E4, E5) throws -> Result
 
     let source1: Observable<E1>
     let source2: Observable<E2>
@@ -532,13 +532,13 @@ final class CombineLatestSink6_<E1, E2, E3, E4, E5, E6, Observer: ObserverType>
         ])
     }
 
-    override func getResult() throws-> Result {
+    override func getResult() throws -> Result {
         try self.parent.resultSelector(self.latestElement1, self.latestElement2, self.latestElement3, self.latestElement4, self.latestElement5, self.latestElement6)
     }
 }
 
 final class CombineLatest6<E1, E2, E3, E4, E5, E6, Result> : Producer<Result> {
-    typealias ResultSelector = (E1, E2, E3, E4, E5, E6) throws-> Result
+    typealias ResultSelector = (E1, E2, E3, E4, E5, E6) throws -> Result
 
     let source1: Observable<E1>
     let source2: Observable<E2>
@@ -663,13 +663,13 @@ final class CombineLatestSink7_<E1, E2, E3, E4, E5, E6, E7, Observer: ObserverTy
         ])
     }
 
-    override func getResult() throws-> Result {
+    override func getResult() throws -> Result {
         try self.parent.resultSelector(self.latestElement1, self.latestElement2, self.latestElement3, self.latestElement4, self.latestElement5, self.latestElement6, self.latestElement7)
     }
 }
 
 final class CombineLatest7<E1, E2, E3, E4, E5, E6, E7, Result> : Producer<Result> {
-    typealias ResultSelector = (E1, E2, E3, E4, E5, E6, E7) throws-> Result
+    typealias ResultSelector = (E1, E2, E3, E4, E5, E6, E7) throws -> Result
 
     let source1: Observable<E1>
     let source2: Observable<E2>
@@ -801,13 +801,13 @@ final class CombineLatestSink8_<E1, E2, E3, E4, E5, E6, E7, E8, Observer: Observ
         ])
     }
 
-    override func getResult() throws-> Result {
+    override func getResult() throws -> Result {
         try self.parent.resultSelector(self.latestElement1, self.latestElement2, self.latestElement3, self.latestElement4, self.latestElement5, self.latestElement6, self.latestElement7, self.latestElement8)
     }
 }
 
 final class CombineLatest8<E1, E2, E3, E4, E5, E6, E7, E8, Result> : Producer<Result> {
-    typealias ResultSelector = (E1, E2, E3, E4, E5, E6, E7, E8) throws-> Result
+    typealias ResultSelector = (E1, E2, E3, E4, E5, E6, E7, E8) throws -> Result
 
     let source1: Observable<E1>
     let source2: Observable<E2>

RxSwift/Observables/CombineLatest+arity.tt

@@ -20,7 +20,7 @@ extension ObservableType {
     - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
     */
     public static func combineLatest<<%= (Array(1...i).map { "O\($0): ObservableType" }).joined(separator: ", ") %>>
-        (<%= (Array(1...i).map { "_ source\($0): O\($0)" }).joined(separator: ", ") %>, resultSelector: @escaping (<%= (Array(1...i).map { "O\($0).E" }).joined(separator: ", ") %>) throws -> Element)
+        (<%= (Array(1...i).map { "_ source\($0): O\($0)" }).joined(separator: ", ") %>, resultSelector: @escaping (<%= (Array(1...i).map { "O\($0).Element" }).joined(separator: ", ") %>) throws -> Element)
             -> Observable<Element> {
         return CombineLatest<%= i %>(
             <%= (Array(1...i).map { "source\($0): source\($0).asObservable()" }).joined(separator: ", ") %>,
@@ -39,7 +39,7 @@ extension ObservableType where Element == Any {
     */
     public static func combineLatest<<%= (Array(1...i).map { "O\($0): ObservableType" }).joined(separator: ", ") %>>
         (<%= (Array(1...i).map { "_ source\($0): O\($0)" }).joined(separator: ", ") %>)
-            -> Observable<(<%= (Array(1...i).map { "O\($0).E" }).joined(separator: ", ") %>)> {
+            -> Observable<(<%= (Array(1...i).map { "O\($0).Element" }).joined(separator: ", ") %>)> {
         return CombineLatest<%= i %>(
             <%= (Array(1...i).map { "source\($0): source\($0).asObservable()" }).joined(separator: ", ") %>,
             resultSelector: { (<%= (Array(0..<i).map { "$\($0)" }).joined(separator: ", ") %>) }

RxSwift/Observables/Merge.swift

@@ -132,7 +132,7 @@ extension ObservableType {
     
     public func concatMap<Source: ObservableConvertibleType>(_ selector: @escaping (Element) throws -> Source)
         -> Observable<Source.Element> {
-            return ConcatMap(source: self.asObservable(), selector: selector)
+        return ConcatMap(source: self.asObservable(), selector: selector)
     }
 }
 

RxSwift/Observables/Producer.swift

@@ -6,7 +6,7 @@
 //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
 //
 
-class Producer<Element> : Observable<Element> {
+class Producer<Element>: Observable<Element> {
     override init() {
         super.init()
     }

RxSwift/Observables/Zip+arity.tt

@@ -20,7 +20,7 @@ extension ObservableType {
     - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
     */
     public static func zip<<%= (Array(1...i).map { "O\($0): ObservableType" }).joined(separator: ", ") %>>
-        (<%= (Array(1...i).map { "_ source\($0): O\($0)" }).joined(separator: ", ") %>, resultSelector: @escaping (<%= (Array(1...i).map { "O\($0).E" }).joined(separator: ", ") %>) throws -> Element)
+        (<%= (Array(1...i).map { "_ source\($0): O\($0)" }).joined(separator: ", ") %>, resultSelector: @escaping (<%= (Array(1...i).map { "O\($0).Element" }).joined(separator: ", ") %>) throws -> Element)
         -> Observable<Element> {
         return Zip<%= i %>(
             <%= (Array(1...i).map { "source\($0): source\($0).asObservable()" }).joined(separator: ", ") %>,
@@ -39,7 +39,7 @@ extension ObservableType where Element == Any {
     */
     public static func zip<<%= (Array(1...i).map { "O\($0): ObservableType" }).joined(separator: ", ") %>>
         (<%= (Array(1...i).map { "_ source\($0): O\($0)" }).joined(separator: ", ") %>)
-        -> Observable<(<%= (Array(1...i).map { "O\($0).E" }).joined(separator: ", ") %>)> {
+        -> Observable<(<%= (Array(1...i).map { "O\($0).Element" }).joined(separator: ", ") %>)> {
         return Zip<%= i %>(
             <%= (Array(1...i).map { "source\($0): source\($0).asObservable()" }).joined(separator: ", ") %>,
             resultSelector: { (<%= (Array(0..<i).map { "$\($0)" }).joined(separator: ", ") %>) }

RxSwift/Traits/Infallible/Infallible+CombineLatest+arity.swift

@@ -0,0 +1,165 @@
+// This file is autogenerated. Take a look at `Preprocessor` target in RxSwift project 
+//
+//  Infallible+CombineLatest+arity.tt
+//  RxSwift
+//
+//  Created by Shai Mishali on 27/08/2020.
+//  Copyright © 2020 Krunoslav Zaher. All rights reserved.
+//
+
+
+
+
+// 2
+
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.
+
+    - seealso: [combineLatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
+
+    - parameter resultSelector: Function to invoke whenever any of the sources produces an element.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func combineLatest<I1: InfallibleType, I2: InfallibleType>
+        (_ source1: I1, _ source2: I2, resultSelector: @escaping (I1.Element, I2.Element) throws -> Element)
+            -> Infallible<Element> {
+        Infallible(CombineLatest2(
+            source1: source1.asObservable(), source2: source2.asObservable(),
+            resultSelector: resultSelector
+        ))
+    }
+}
+
+
+// 3
+
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.
+
+    - seealso: [combineLatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
+
+    - parameter resultSelector: Function to invoke whenever any of the sources produces an element.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func combineLatest<I1: InfallibleType, I2: InfallibleType, I3: InfallibleType>
+        (_ source1: I1, _ source2: I2, _ source3: I3, resultSelector: @escaping (I1.Element, I2.Element, I3.Element) throws -> Element)
+            -> Infallible<Element> {
+        Infallible(CombineLatest3(
+            source1: source1.asObservable(), source2: source2.asObservable(), source3: source3.asObservable(),
+            resultSelector: resultSelector
+        ))
+    }
+}
+
+
+// 4
+
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.
+
+    - seealso: [combineLatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
+
+    - parameter resultSelector: Function to invoke whenever any of the sources produces an element.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func combineLatest<I1: InfallibleType, I2: InfallibleType, I3: InfallibleType, I4: InfallibleType>
+        (_ source1: I1, _ source2: I2, _ source3: I3, _ source4: I4, resultSelector: @escaping (I1.Element, I2.Element, I3.Element, I4.Element) throws -> Element)
+            -> Infallible<Element> {
+        Infallible(CombineLatest4(
+            source1: source1.asObservable(), source2: source2.asObservable(), source3: source3.asObservable(), source4: source4.asObservable(),
+            resultSelector: resultSelector
+        ))
+    }
+}
+
+
+// 5
+
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.
+
+    - seealso: [combineLatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
+
+    - parameter resultSelector: Function to invoke whenever any of the sources produces an element.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func combineLatest<I1: InfallibleType, I2: InfallibleType, I3: InfallibleType, I4: InfallibleType, I5: InfallibleType>
+        (_ source1: I1, _ source2: I2, _ source3: I3, _ source4: I4, _ source5: I5, resultSelector: @escaping (I1.Element, I2.Element, I3.Element, I4.Element, I5.Element) throws -> Element)
+            -> Infallible<Element> {
+        Infallible(CombineLatest5(
+            source1: source1.asObservable(), source2: source2.asObservable(), source3: source3.asObservable(), source4: source4.asObservable(), source5: source5.asObservable(),
+            resultSelector: resultSelector
+        ))
+    }
+}
+
+
+// 6
+
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.
+
+    - seealso: [combineLatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
+
+    - parameter resultSelector: Function to invoke whenever any of the sources produces an element.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func combineLatest<I1: InfallibleType, I2: InfallibleType, I3: InfallibleType, I4: InfallibleType, I5: InfallibleType, I6: InfallibleType>
+        (_ source1: I1, _ source2: I2, _ source3: I3, _ source4: I4, _ source5: I5, _ source6: I6, resultSelector: @escaping (I1.Element, I2.Element, I3.Element, I4.Element, I5.Element, I6.Element) throws -> Element)
+            -> Infallible<Element> {
+        Infallible(CombineLatest6(
+            source1: source1.asObservable(), source2: source2.asObservable(), source3: source3.asObservable(), source4: source4.asObservable(), source5: source5.asObservable(), source6: source6.asObservable(),
+            resultSelector: resultSelector
+        ))
+    }
+}
+
+
+// 7
+
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.
+
+    - seealso: [combineLatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
+
+    - parameter resultSelector: Function to invoke whenever any of the sources produces an element.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func combineLatest<I1: InfallibleType, I2: InfallibleType, I3: InfallibleType, I4: InfallibleType, I5: InfallibleType, I6: InfallibleType, I7: InfallibleType>
+        (_ source1: I1, _ source2: I2, _ source3: I3, _ source4: I4, _ source5: I5, _ source6: I6, _ source7: I7, resultSelector: @escaping (I1.Element, I2.Element, I3.Element, I4.Element, I5.Element, I6.Element, I7.Element) throws -> Element)
+            -> Infallible<Element> {
+        Infallible(CombineLatest7(
+            source1: source1.asObservable(), source2: source2.asObservable(), source3: source3.asObservable(), source4: source4.asObservable(), source5: source5.asObservable(), source6: source6.asObservable(), source7: source7.asObservable(),
+            resultSelector: resultSelector
+        ))
+    }
+}
+
+
+// 8
+
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.
+
+    - seealso: [combineLatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
+
+    - parameter resultSelector: Function to invoke whenever any of the sources produces an element.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func combineLatest<I1: InfallibleType, I2: InfallibleType, I3: InfallibleType, I4: InfallibleType, I5: InfallibleType, I6: InfallibleType, I7: InfallibleType, I8: InfallibleType>
+        (_ source1: I1, _ source2: I2, _ source3: I3, _ source4: I4, _ source5: I5, _ source6: I6, _ source7: I7, _ source8: I8, resultSelector: @escaping (I1.Element, I2.Element, I3.Element, I4.Element, I5.Element, I6.Element, I7.Element, I8.Element) throws -> Element)
+            -> Infallible<Element> {
+        Infallible(CombineLatest8(
+            source1: source1.asObservable(), source2: source2.asObservable(), source3: source3.asObservable(), source4: source4.asObservable(), source5: source5.asObservable(), source6: source6.asObservable(), source7: source7.asObservable(), source8: source8.asObservable(),
+            resultSelector: resultSelector
+        ))
+    }
+}
+

RxSwift/Traits/Infallible/Infallible+CombineLatest+arity.tt

@@ -0,0 +1,32 @@
+//
+//  Infallible+CombineLatest+arity.tt
+//  RxSwift
+//
+//  Created by Shai Mishali on 27/08/2020.
+//  Copyright © 2020 Krunoslav Zaher. All rights reserved.
+//
+
+
+<% for i in 2 ... 8 { %>
+
+// <%= i %>
+
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.
+
+    - seealso: [combineLatest operator on reactivex.io](http://reactivex.io/documentation/operators/combinelatest.html)
+
+    - parameter resultSelector: Function to invoke whenever any of the sources produces an element.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func combineLatest<<%= (Array(1...i).map { "I\($0): InfallibleType" }).joined(separator: ", ") %>>
+        (<%= (Array(1...i).map { "_ source\($0): I\($0)" }).joined(separator: ", ") %>, resultSelector: @escaping (<%= (Array(1...i).map { "I\($0).Element" }).joined(separator: ", ") %>) throws -> Element)
+            -> Infallible<Element> {
+        Infallible(CombineLatest<%= i %>(
+            <%= (Array(1...i).map { "source\($0): source\($0).asObservable()" }).joined(separator: ", ") %>,
+            resultSelector: resultSelector
+        ))
+    }
+}
+<% } %>

RxSwift/Traits/Infallible/Infallible+Create.swift

@@ -0,0 +1,44 @@
+//
+//  Infallible+Create.swift
+//  RxSwift
+//
+//  Created by Shai Mishali on 27/08/2020.
+//  Copyright © 2020 Krunoslav Zaher. All rights reserved.
+//
+
+import Foundation
+
+public enum InfallibleEvent<Element> {
+    /// Next element is produced.
+    case next(Element)
+
+    /// Sequence completed successfully.
+    case completed
+}
+
+extension Infallible {
+    public typealias InfallibleObserver = (InfallibleEvent<Element>) -> Void
+
+    /**
+     Creates an observable sequence from a specified subscribe method implementation.
+
+     - seealso: [create operator on reactivex.io](http://reactivex.io/documentation/operators/create.html)
+
+     - parameter subscribe: Implementation of the resulting observable sequence's `subscribe` method.
+     - returns: The observable sequence with the specified implementation for the `subscribe` method.
+     */
+    public static func create(subscribe: @escaping (@escaping InfallibleObserver) -> Disposable) -> Infallible<Element> {
+        let source = Observable<Element>.create { observer in
+            subscribe { event in
+                switch event {
+                case .next(let element):
+                    observer.onNext(element)
+                case .completed:
+                    observer.onCompleted()
+                }
+            }
+        }
+
+        return Infallible(source)
+    }
+}

RxSwift/Traits/Infallible/Infallible+Operators.swift

@@ -0,0 +1,87 @@
+//
+//  Infallible+Operators.swift
+//  RxSwift
+//
+//  Created by Shai Mishali on 27/08/2020.
+//  Copyright © 2020 Krunoslav Zaher. All rights reserved.
+//
+
+// MARK: - Filter
+extension Infallible {
+    /**
+     Filters the elements of an observable sequence based on a predicate.
+
+     - seealso: [filter operator on reactivex.io](http://reactivex.io/documentation/operators/filter.html)
+
+     - parameter predicate: A function to test each source element for a condition.
+     - returns: An observable sequence that contains elements from the input sequence that satisfy the condition.
+     */
+    public func filter(_ predicate: @escaping (Element) -> Bool)
+        -> Infallible<Element> {
+        Infallible(asObservable().filter(predicate))
+    }
+}
+
+// MARK: - Map
+extension InfallibleType {
+    /**
+     Projects each element of an observable sequence into a new form.
+
+     - seealso: [map operator on reactivex.io](http://reactivex.io/documentation/operators/map.html)
+
+     - parameter transform: A transform function to apply to each source element.
+     - returns: An observable sequence whose elements are the result of invoking the transform function on each element of source.
+
+     */
+    public func map<Result>(_ transform: @escaping (Element) -> Result)
+        -> Infallible<Result> {
+        Infallible(asObservable().map(transform))
+    }
+
+    /**
+     Projects each element of an observable sequence into an optional form and filters all optional results.
+
+     - parameter transform: A transform function to apply to each source element and which returns an element or nil.
+     - returns: An observable sequence whose elements are the result of filtering the transform function for each element of the source.
+
+     */
+    public func compactMap<Result>(_ transform: @escaping (Element) -> Result?)
+        -> Infallible<Result> {
+        Infallible(asObservable().compactMap(transform))
+    }
+}
+
+// MARK: - Scan
+extension InfallibleType {
+    /**
+     Applies an accumulator function over an observable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value.
+
+     For aggregation behavior with no intermediate results, see `reduce`.
+
+     - seealso: [scan operator on reactivex.io](http://reactivex.io/documentation/operators/scan.html)
+
+     - parameter seed: The initial accumulator value.
+     - parameter accumulator: An accumulator function to be invoked on each element.
+     - returns: An observable sequence containing the accumulated values.
+     */
+    public func scan<Seed>(into seed: Seed, accumulator: @escaping (inout Seed, Element) -> Void)
+        -> Infallible<Seed> {
+        Infallible(asObservable().scan(into: seed, accumulator: accumulator))
+    }
+
+    /**
+     Applies an accumulator function over an observable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value.
+
+     For aggregation behavior with no intermediate results, see `reduce`.
+
+     - seealso: [scan operator on reactivex.io](http://reactivex.io/documentation/operators/scan.html)
+
+     - parameter seed: The initial accumulator value.
+     - parameter accumulator: An accumulator function to be invoked on each element.
+     - returns: An observable sequence containing the accumulated values.
+     */
+    public func scan<Seed>(_ seed: Seed, accumulator: @escaping (Seed, Element) -> Seed)
+        -> Infallible<Seed> {
+        Infallible(asObservable().scan(seed, accumulator: accumulator))
+    }
+}

RxSwift/Traits/Infallible/Infallible+Zip+arity.swift

@@ -0,0 +1,143 @@
+// This file is autogenerated. Take a look at `Preprocessor` target in RxSwift project 
+//
+//  Infallible+Zip+arity.swift
+//  RxSwift
+//
+//  Created by Shai Mishali on 27/8/20.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+
+// 2
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
+
+    - seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
+
+    - parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func zip<E1, E2>(_ source1: Infallible<E1>, _ source2: Infallible<E2>, resultSelector: @escaping (E1, E2) throws -> Element)
+        -> Infallible<Element> {
+        Infallible(
+            Observable.zip(source1.asObservable(), source2.asObservable(), resultSelector: resultSelector)
+        )
+    }
+}
+
+
+// 3
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
+
+    - seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
+
+    - parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func zip<E1, E2, E3>(_ source1: Infallible<E1>, _ source2: Infallible<E2>, _ source3: Infallible<E3>, resultSelector: @escaping (E1, E2, E3) throws -> Element)
+        -> Infallible<Element> {
+        Infallible(
+            Observable.zip(source1.asObservable(), source2.asObservable(), source3.asObservable(), resultSelector: resultSelector)
+        )
+    }
+}
+
+
+// 4
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
+
+    - seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
+
+    - parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func zip<E1, E2, E3, E4>(_ source1: Infallible<E1>, _ source2: Infallible<E2>, _ source3: Infallible<E3>, _ source4: Infallible<E4>, resultSelector: @escaping (E1, E2, E3, E4) throws -> Element)
+        -> Infallible<Element> {
+        Infallible(
+            Observable.zip(source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable(), resultSelector: resultSelector)
+        )
+    }
+}
+
+
+// 5
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
+
+    - seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
+
+    - parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func zip<E1, E2, E3, E4, E5>(_ source1: Infallible<E1>, _ source2: Infallible<E2>, _ source3: Infallible<E3>, _ source4: Infallible<E4>, _ source5: Infallible<E5>, resultSelector: @escaping (E1, E2, E3, E4, E5) throws -> Element)
+        -> Infallible<Element> {
+        Infallible(
+            Observable.zip(source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable(), source5.asObservable(), resultSelector: resultSelector)
+        )
+    }
+}
+
+
+// 6
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
+
+    - seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
+
+    - parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func zip<E1, E2, E3, E4, E5, E6>(_ source1: Infallible<E1>, _ source2: Infallible<E2>, _ source3: Infallible<E3>, _ source4: Infallible<E4>, _ source5: Infallible<E5>, _ source6: Infallible<E6>, resultSelector: @escaping (E1, E2, E3, E4, E5, E6) throws -> Element)
+        -> Infallible<Element> {
+        Infallible(
+            Observable.zip(source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable(), source5.asObservable(), source6.asObservable(), resultSelector: resultSelector)
+        )
+    }
+}
+
+
+// 7
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
+
+    - seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
+
+    - parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func zip<E1, E2, E3, E4, E5, E6, E7>(_ source1: Infallible<E1>, _ source2: Infallible<E2>, _ source3: Infallible<E3>, _ source4: Infallible<E4>, _ source5: Infallible<E5>, _ source6: Infallible<E6>, _ source7: Infallible<E7>, resultSelector: @escaping (E1, E2, E3, E4, E5, E6, E7) throws -> Element)
+        -> Infallible<Element> {
+        Infallible(
+            Observable.zip(source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable(), source5.asObservable(), source6.asObservable(), source7.asObservable(), resultSelector: resultSelector)
+        )
+    }
+}
+
+
+// 8
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
+
+    - seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
+
+    - parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func zip<E1, E2, E3, E4, E5, E6, E7, E8>(_ source1: Infallible<E1>, _ source2: Infallible<E2>, _ source3: Infallible<E3>, _ source4: Infallible<E4>, _ source5: Infallible<E5>, _ source6: Infallible<E6>, _ source7: Infallible<E7>, _ source8: Infallible<E8>, resultSelector: @escaping (E1, E2, E3, E4, E5, E6, E7, E8) throws -> Element)
+        -> Infallible<Element> {
+        Infallible(
+            Observable.zip(source1.asObservable(), source2.asObservable(), source3.asObservable(), source4.asObservable(), source5.asObservable(), source6.asObservable(), source7.asObservable(), source8.asObservable(), resultSelector: resultSelector)
+        )
+    }
+}
+
+

RxSwift/Traits/Infallible/Infallible+Zip+arity.tt

@@ -0,0 +1,28 @@
+//
+//  Infallible+Zip+arity.swift
+//  RxSwift
+//
+//  Created by Shai Mishali on 27/8/20.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+<% for i in 2 ... 8 { %>
+// <%= i %>
+extension Infallible {
+    /**
+    Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index.
+
+    - seealso: [zip operator on reactivex.io](http://reactivex.io/documentation/operators/zip.html)
+
+    - parameter resultSelector: Function to invoke for each series of elements at corresponding indexes in the sources.
+    - returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
+    */
+    public static func zip<<%= (Array(1...i).map { "E\($0)" }).joined(separator: ", ") %>>(<%= (Array(1...i).map { "_ source\($0): Infallible<E\($0)>" }).joined(separator: ", ") %>, resultSelector: @escaping (<%= (Array(1...i).map { "E\($0)" }).joined(separator: ", ") %>) throws -> Element)
+        -> Infallible<Element> {
+        Infallible(
+            Observable.zip(<%= (Array(1...i).map { "source\($0).asObservable()" }).joined(separator: ", ") %>, resultSelector: resultSelector)
+        )
+    }
+}
+
+<% } %>

RxSwift/Traits/Infallible/Infallible.swift

@@ -0,0 +1,57 @@
+//
+//  Infallible.swift
+//  RxSwift
+//
+//  Created by Shai Mishali on 27/08/2020.
+//  Copyright © 2020 Krunoslav Zaher. All rights reserved.
+//
+
+public protocol InfallibleType: ObservableConvertibleType {}
+
+/// `Infallible` is an `Observable`-like push-style interface
+/// which is guaranteed to not emit error events.
+///
+/// Unlike `SharedSequence`, it does not share its resources or
+/// replay its events, but acts as a standard `Observable`.
+public struct Infallible<Element>: InfallibleType {
+    private let source: Observable<Element>
+
+    init(_ source: Observable<Element>) {
+        self.source = source
+    }
+
+    public func asObservable() -> Observable<Element> { source }
+}
+
+extension InfallibleType {
+    /**
+    Subscribes an element handler, a completion handler and disposed handler to an observable sequence.
+    This method can be only called from `MainThread`.
+
+    Error callback is not exposed because `Driver` can't error out.
+
+    - parameter onNext: Action to invoke for each element in the observable sequence.
+    - parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
+    gracefully completed, errored, or if the generation is canceled by disposing subscription)
+    - parameter onDisposed: Action to invoke upon any type of termination of sequence (if the sequence has
+    gracefully completed, errored, or if the generation is canceled by disposing subscription)
+    - returns: Subscription object used to unsubscribe from the observable sequence.
+    */
+    public func subscribe(onNext: ((Element) -> Void)? = nil,
+                          onCompleted: (() -> Void)? = nil,
+                          onDisposed: (() -> Void)? = nil) -> Disposable {
+        self.asObservable().subscribe(onNext: onNext,
+                                      onCompleted: onCompleted,
+                                      onDisposed: onDisposed)
+    }
+
+    /**
+     Subscribes an event handler to an observable sequence.
+
+     - parameter on: Action to invoke for each event in the observable sequence.
+     - returns: Subscription object used to unsubscribe from the observable sequence.
+     */
+    public func subscribe(_ on: @escaping (Event<Element>) -> Void) -> Disposable {
+        self.asObservable().subscribe(on)
+    }
+}

RxSwift/Traits/Infallible/ObservableConvertibleType+Infallible.swift

@@ -0,0 +1,21 @@
+//
+//  ObservableConvertibleType+Infallible.swift
+//  RxSwift
+//
+//  Created by Shai Mishali on 27/08/2020.
+//  Copyright © 2020 Krunoslav Zaher. All rights reserved.
+//
+
+extension ObservableConvertibleType {
+    func asInfallible(onErrorJustReturn element: Element) -> Infallible<Element> {
+        Infallible(self.asObservable().catchErrorJustReturn(element))
+    }
+
+    func asInfallible(onErrorFallbackTo infallible: Infallible<Element>) -> Infallible<Element> {
+        Infallible(self.asObservable().catchError { _ in infallible.asObservable() })
+    }
+
+    func asInfallible(onErrorRecover: @escaping (Swift.Error) -> Infallible<Element>) -> Infallible<Element> {
+        Infallible(asObservable().catchError { onErrorRecover($0).asObservable() })
+    }
+}

Tests/RxSwiftTests/PrimitiveSequenceTest+zip+arity.swift

@@ -177,7 +177,7 @@ extension MaybeTest {
 
 extension SingleTest {
     func testZip6_selector() {
-        let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1)) { a, b, c, d, e, f -> Int in a + b + c + d + e + f }
+        let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1)) { $0 + $1 + $2 + $3 + $4 + $5 }
 
         let result = try! singleResult
             .toBlocking().first()!
@@ -185,8 +185,7 @@ extension SingleTest {
     }
 
     func testZip6_tuple() {
-        let singleZip = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1))
-        let singleResult = singleZip.map { $0.0 + $0.1 + $0.2 + $0.3 + $0.4 + $0.5 }
+        let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1)).map { $0 + $1 + $2 + $3 + $4 + $5 }
 
         let result = try! singleResult
             .toBlocking().first()!
@@ -204,10 +203,9 @@ extension MaybeTest {
     }
 
     func testZip6_tuple() {
-        let maybeZip = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1))
-        let maybeResult = maybeZip.map { $0.0 + $0.1 + $0.2 + $0.3 + $0.4 + $0.5 }
+        let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1)).map { $0 + $1 + $2 + $3 + $4 + $5 }
 
-        let result = try! maybeResult
+        let result = try! singleResult
             .toBlocking().first()!
         XCTAssertEqual(result, 6)
     }
@@ -227,8 +225,7 @@ extension SingleTest {
     }
 
     func testZip7_tuple() {
-        let singleZip = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1))
-        let singleResult = singleZip.map { $0.0 + $0.1 + $0.2 + $0.3 + $0.4 + $0.5 + $0.6 }
+        let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1)).map { $0 + $1 + $2 + $3 + $4 + $5 + $6 }
 
         let result = try! singleResult
             .toBlocking().first()!
@@ -246,10 +243,9 @@ extension MaybeTest {
     }
 
     func testZip7_tuple() {
-        let maybeZip = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1))
-        let maybeResult = maybeZip.map { $0.0 + $0.1 + $0.2 + $0.3 + $0.4 + $0.5 + $0.6 }
+        let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1)).map { $0 + $1 + $2 + $3 + $4 + $5 + $6 }
 
-        let result = try! maybeResult
+        let result = try! singleResult
             .toBlocking().first()!
         XCTAssertEqual(result, 7)
     }
@@ -269,8 +265,7 @@ extension SingleTest {
     }
 
     func testZip8_tuple() {
-        let singleZip = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1))
-        let singleResult = singleZip.map { $0.0 + $0.1 + $0.2 + $0.3 + $0.4 + $0.5 + $0.6 + $0.7 }
+        let singleResult: Single<Int> = Single.zip(Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1), Single.just(1)).map { $0 + $1 + $2 + $3 + $4 + $5 + $6 + $7 }
 
         let result = try! singleResult
             .toBlocking().first()!
@@ -288,10 +283,9 @@ extension MaybeTest {
     }
 
     func testZip8_tuple() {
-        let maybeZip = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1))
-        let maybeResult = maybeZip.map { $0.0 + $0.1 + $0.2 + $0.3 + $0.4 + $0.5 + $0.6 + $0.7 }
+        let singleResult: Maybe<Int> = Maybe.zip(Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1), Maybe.just(1)).map { $0 + $1 + $2 + $3 + $4 + $5 + $6 + $7 }
 
-        let result = try! maybeResult
+        let result = try! singleResult
             .toBlocking().first()!
         XCTAssertEqual(result, 8)
     }