Reduce one character generics usage

Author: M0rtyMerr

Source/RxCocoa/mapTo+RxCocoa.swift

@@ -15,12 +15,12 @@ extension SharedSequenceConvertibleType {
      - parameter value: A constant that each element of the input sequence is being replaced with
      - returns: An unit containing the values `value` provided as a parameter
      */
-    public func mapTo<R>(_ value: R) -> SharedSequence<SharingStrategy, R> {
+    public func mapTo<Result>(_ value: Result) -> SharedSequence<SharingStrategy, Result> {
         return map { _ in value }
     }
 
     @available(*, deprecated, renamed: "mapTo(_:)")
-    public func map<R>(to value: R) -> SharedSequence<SharingStrategy, R> {
+    public func map<Result>(to value: Result) -> SharedSequence<SharingStrategy, Result> {
         return map { _ in value }
     }
 }

Source/RxCocoa/unwrap+SharedSequence.swift

@@ -16,7 +16,7 @@ extension SharedSequence {
      - returns: A SharedSequence of non-optional elements
      */
 
-    public func unwrap<T>() -> SharedSequence<SharingStrategy, T> where Element == T? {
+    public func unwrap<Result>() -> SharedSequence<SharingStrategy, Result> where Element == Result? {
         return self.filter { $0 != nil }.map { $0! }
     }
 }

Source/RxSwift/and.swift

@@ -51,7 +51,8 @@ extension ObservableType where Element == Bool {
 
 	Use `asSingle()` or `asObservable()` to convert to your requirements.
 	*/
-	public static func and<C: Collection>(_ collection: C) -> Maybe<Element> where C.Element: ObservableType, C.Element.Element == Element {
+    public static func and<Collection: Swift.Collection>(_ collection: Collection)
+        -> Maybe<Element> where Collection.Element: ObservableType, Collection.Element.Element == Element {
 		return Maybe.create { observer in
 			var emitted = [Bool](repeating: false, count: Int(collection.count))
 			var completed = 0
@@ -99,7 +100,7 @@ extension ObservableType where Element == Bool {
 
 	Use `asSingle()` or `asObservable()` to convert to your requirements.
 	*/
-	public static func and<O: ObservableType>(_ sources: O ...) -> Maybe<Element> where O.Element == Element {
+	public static func and<Observable: ObservableType>(_ sources: Observable ...) -> Maybe<Element> where Observable.Element == Element {
 		return and(sources)
 	}
 }

Source/RxSwift/cascade.swift

@@ -20,7 +20,7 @@ extension Observable where Element: ObservableType {
 	- parameter observables: a sequence of observables which will all be immediately subscribed to
 	- returns: An observable sequence that contains elements from the latest observable sequence that emitted elements
 	*/
-	public static func cascade<S: Sequence>(_ observables: S) -> Observable<Element.Element> where S.Element == Element {
+    public static func cascade<Sequebce: Swift.Sequence>(_ observables: Sequebce) -> Observable<Element.Element> where Sequebce.Element == Element {
         let flow = Array(observables)
         if flow.isEmpty {
             return Observable<Element.Element>.empty()

Source/RxSwift/ofType.swift

@@ -19,9 +19,9 @@ extension ObservableType {
      - parameter type: The Type to filter each source element.
      - returns: An observable sequence that contains elements which is an instance of the suppplied type.
      */
-    public func ofType<T>(_ type: T.Type) -> Observable<T> {
+    public func ofType<Result>(_ type: Result.Type) -> Observable<Result> {
         return self.filterMap {
-            guard let result = $0 as? T else { return .ignore }
+            guard let result = $0 as? Result else { return .ignore }
             return .map(result)
         }
     }

Source/RxSwift/pausable.swift

@@ -21,7 +21,7 @@ extension ObservableType {
 	- returns: The observable sequence which is paused based upon the pauser observable sequence.
 	*/
 
-    public func pausable<P: ObservableType> (_ pauser: P) -> Observable<Element> where P.Element == Bool {
+    public func pausable<Pauser: ObservableType> (_ pauser: Pauser) -> Observable<Element> where Pauser.Element == Bool {
 		return withLatestFrom(pauser) { element, paused in
 				(element, paused)
 			}

Source/RxSwift/pausableBuffered.swift

@@ -26,7 +26,7 @@ extension ObservableType {
      - parameter flushOnError: If `true` buffered elements will be flushed when the source errors. Default `true`.
      - returns: The observable sequence which is paused and resumed based upon the pauser observable sequence.
      */
-    public func pausableBuffered<P: ObservableType> (_ pauser: P, limit: Int? = 1, flushOnCompleted: Bool = true, flushOnError: Bool = true) -> Observable<Element> where P.Element == Bool {
+    public func pausableBuffered<Pauser: ObservableType> (_ pauser: Pauser, limit: Int? = 1, flushOnCompleted: Bool = true, flushOnError: Bool = true) -> Observable<Element> where Pauser.Element == Bool {
 
         return Observable<Element>.create { observer in
             var buffer: [Element] = []

Source/RxSwift/unwrap.swift

@@ -17,7 +17,7 @@ extension ObservableType {
      - returns: An observable sequence of non-optional elements
      */
 
-    public func unwrap<T>() -> Observable<T> where Element == T? {
+    public func unwrap<Result>() -> Observable<Result> where Element == Result? {
         return self.compactMap { $0 }
     }
 }

Source/RxSwift/zipWith.swift

@@ -21,7 +21,7 @@ extension ObservableConvertibleType {
 
      - Returns: An observable sequence containing the result of combining elements of the sources using the specified result selector function.
      */
-    public func zip<O2, ResultType>(with second: O2, resultSelector: @escaping (Element, O2.Element) throws -> ResultType) -> Observable<ResultType> where O2: ObservableConvertibleType {
+    public func zip<Observable2: ObservableConvertibleType, ResultType>(with second: Observable2, resultSelector: @escaping (Element, Observable2.Element) throws -> ResultType) -> Observable<ResultType> {
         return Observable.zip(asObservable(), second.asObservable(), resultSelector: resultSelector)
     }
 }