[stdlib] Standardize function signature spacing

stdlib/public/core/Bool.swift

@@ -141,7 +141,7 @@ extension Bool : Equatable, Hashable {
   }
 
   @_transparent
-  public static func ==(lhs: Bool, rhs: Bool) -> Bool {
+  public static func == (lhs: Bool, rhs: Bool) -> Bool {
     return Bool(Builtin.cmp_eq_Int1(lhs._value, rhs._value))
   }
 }
@@ -167,7 +167,7 @@ extension Bool {
   ///
   /// - Parameter a: The Boolean value to negate.
   @_transparent
-  public static prefix func !(a: Bool) -> Bool {
+  public static prefix func ! (a: Bool) -> Bool {
     return Bool(Builtin.xor_Int1(a._value, true._value))
   }
 }
@@ -206,7 +206,7 @@ extension Bool {
   ///   - lhs: The left-hand side of the operation.
   ///   - rhs: The right-hand side of the operation.
   @inline(__always)
-  public static func &&(lhs: Bool, rhs: @autoclosure () throws -> Bool) rethrows
+  public static func && (lhs: Bool, rhs: @autoclosure () throws -> Bool) rethrows
       -> Bool{
     return lhs ? try rhs() : false
   }
@@ -245,7 +245,7 @@ extension Bool {
   ///   - lhs: The left-hand side of the operation.
   ///   - rhs: The right-hand side of the operation.
   @inline(__always)
-  public static func ||(lhs: Bool, rhs: @autoclosure () throws -> Bool) rethrows
+  public static func || (lhs: Bool, rhs: @autoclosure () throws -> Bool) rethrows
       -> Bool {
     return lhs ? true : try rhs()
   }

stdlib/public/core/BridgeObjectiveC.swift

@@ -246,8 +246,10 @@ public func _forceBridgeFromObjectiveC<T>(_ x: AnyObject, _: T.Type) -> T {
 /// Convert `x` from its Objective-C representation to its Swift
 /// representation.
 @_silgen_name("_forceBridgeFromObjectiveC_bridgeable")
-public func _forceBridgeFromObjectiveC_bridgeable<T:_ObjectiveCBridgeable>
-  (_ x: T._ObjectiveCType, _: T.Type) -> T {
+public func _forceBridgeFromObjectiveC_bridgeable<T:_ObjectiveCBridgeable> (
+  _ x: T._ObjectiveCType,
+  _: T.Type
+) -> T {
   var result: T?
   T._forceBridgeFromObjectiveC(x, result: &result)
   return result!
@@ -483,7 +485,7 @@ extension AutoreleasingUnsafeMutablePointer : CustomDebugStringConvertible {
 }
 
 @_transparent
-public func == <Pointee> (
+public func == <Pointee>(
   lhs: AutoreleasingUnsafeMutablePointer<Pointee>,
   rhs: AutoreleasingUnsafeMutablePointer<Pointee>
 ) -> Bool {

stdlib/public/core/Builtin.swift

@@ -129,22 +129,22 @@ internal func _reinterpretCastToAnyObject<T>(_ x: T) -> AnyObject {
 }
 
 @_transparent
-func ==(lhs: Builtin.NativeObject, rhs: Builtin.NativeObject) -> Bool {
+func == (lhs: Builtin.NativeObject, rhs: Builtin.NativeObject) -> Bool {
   return unsafeBitCast(lhs, to: Int.self) == unsafeBitCast(rhs, to: Int.self)
 }
 
 @_transparent
-func !=(lhs: Builtin.NativeObject, rhs: Builtin.NativeObject) -> Bool {
+func != (lhs: Builtin.NativeObject, rhs: Builtin.NativeObject) -> Bool {
   return !(lhs == rhs)
 }
 
 @_transparent
-func ==(lhs: Builtin.RawPointer, rhs: Builtin.RawPointer) -> Bool {
+func == (lhs: Builtin.RawPointer, rhs: Builtin.RawPointer) -> Bool {
   return unsafeBitCast(lhs, to: Int.self) == unsafeBitCast(rhs, to: Int.self)
 }
 
 @_transparent
-func !=(lhs: Builtin.RawPointer, rhs: Builtin.RawPointer) -> Bool {
+func != (lhs: Builtin.RawPointer, rhs: Builtin.RawPointer) -> Bool {
   return !(lhs == rhs)
 }
 

stdlib/public/core/CTypes.swift

@@ -162,7 +162,7 @@ extension UInt {
 }
 
 extension OpaquePointer : Equatable {
-  public static func ==(lhs: OpaquePointer, rhs: OpaquePointer) -> Bool {
+  public static func == (lhs: OpaquePointer, rhs: OpaquePointer) -> Bool {
     return Bool(Builtin.cmp_eq_RawPointer(lhs._rawValue, rhs._rawValue))
   }
 }

stdlib/public/core/Character.swift

@@ -392,7 +392,7 @@ internal var _minASCIICharReprBuiltin: Builtin.Int63 {
 }
 
 extension Character : Equatable {
-  public static func ==(lhs: Character, rhs: Character) -> Bool {
+  public static func == (lhs: Character, rhs: Character) -> Bool {
     switch (lhs._representation, rhs._representation) {
     case let (.small(lbits), .small(rbits)) where
       Bool(Builtin.cmp_uge_Int63(lbits, _minASCIICharReprBuiltin))
@@ -407,7 +407,7 @@ extension Character : Equatable {
 }
 
 extension Character : Comparable {
-  public static func <(lhs: Character, rhs: Character) -> Bool {
+  public static func < (lhs: Character, rhs: Character) -> Bool {
     switch (lhs._representation, rhs._representation) {
     case let (.small(lbits), .small(rbits)) where
       // Note: This is consistent with Foundation but unicode incorrect.

stdlib/public/core/ClosedRange.swift

@@ -395,7 +395,7 @@ public struct ClosedRange<
 ///   - minimum: The lower bound for the range.
 ///   - maximum: The upper bound for the range.
 @_transparent
-public func ... <Bound : Comparable> (minimum: Bound, maximum: Bound)
+public func ... <Bound : Comparable>(minimum: Bound, maximum: Bound)
   -> ClosedRange<Bound> {
   _precondition(
     minimum <= maximum, "Can't form Range with upperBound < lowerBound")
@@ -414,7 +414,7 @@ public func ... <Bound : Comparable> (minimum: Bound, maximum: Bound)
 ///   - minimum: The lower bound for the range.
 ///   - maximum: The upper bound for the range.
 @_transparent
-public func ... <Bound> (
+public func ... <Bound>(
   minimum: Bound, maximum: Bound
 ) -> CountableClosedRange<Bound>
   where

stdlib/public/core/Comparable.swift

@@ -83,7 +83,7 @@
 /// `Comparable` and implement the `<` operator function.
 ///
 ///     extension Date: Comparable {
-///         static func <(lhs: Date, rhs: Date) -> Bool {
+///         static func < (lhs: Date, rhs: Date) -> Bool {
 ///             if lhs.year != rhs.year {
 ///                 return lhs.year < rhs.year
 ///             } else if lhs.month != rhs.month {
@@ -102,7 +102,7 @@
 /// Next, implement the `==` operator function, the requirement inherited from
 /// the `Equatable` protocol.
 ///
-///     func ==(lhs: Date, rhs: Date) -> Bool {
+///     func == (lhs: Date, rhs: Date) -> Bool {
 ///         return lhs.year == rhs.year && lhs.month == rhs.month
 ///             && lhs.day == rhs.day
 ///     }

stdlib/public/core/Equatable.swift

@@ -76,7 +76,7 @@
 /// `Equatable`.
 ///
 ///     extension StreetAddress: Equatable {
-///       static func ==(lhs: StreetAddress, rhs: StreetAddress) -> Bool {
+///       static func == (lhs: StreetAddress, rhs: StreetAddress) -> Bool {
 ///         return
 ///             lhs.number == rhs.number &&
 ///             lhs.street == rhs.street &&
@@ -132,7 +132,7 @@
 ///             self.value = value
 ///         }
 ///
-///         static func ==(lhs: IntegerRef, rhs: IntegerRef) -> Bool {
+///         static func == (lhs: IntegerRef, rhs: IntegerRef) -> Bool {
 ///             return lhs.value == rhs.value
 ///         }
 ///     }

stdlib/public/core/FixedPoint.swift.gyb

@@ -570,7 +570,7 @@ public func ${op}(lhs: ${Self}, rhs: ${Self}) -> ${Self} {
 ///
 /// - SeeAlso: `BitwiseOperations`
 @_transparent
-public prefix func ~(rhs: ${Self}) -> ${Self} {
+public prefix func ~ (rhs: ${Self}) -> ${Self} {
   let mask = ${Self}.subtractWithOverflow(0, 1).0
   return ${Self}(Builtin.xor_${BuiltinName}(rhs._value, mask._value))
 }

stdlib/public/core/FloatingPoint.swift.gyb

@@ -541,12 +541,12 @@ public enum FloatingPointRoundingRule {
 }
 
 @_transparent
-public prefix func +<T : FloatingPoint>(x: T) -> T {
+public prefix func + <T : FloatingPoint>(x: T) -> T {
   return x
 }
 
 @_transparent
-public prefix func -<T : FloatingPoint>(x: T) -> T {
+public prefix func - <T : FloatingPoint>(x: T) -> T {
   return x.negated()
 }
 
@@ -573,7 +573,7 @@ public func ${op[0]}=<T : FloatingPoint>(lhs: inout T, rhs: T) {
 %end
 
 @_transparent
-public func ==<T : FloatingPoint>(lhs: T, rhs: T) -> Bool {
+public func == <T : FloatingPoint>(lhs: T, rhs: T) -> Bool {
   return lhs.isEqual(to: rhs)
 }
 

stdlib/public/core/FloatingPointTypes.swift.gyb

@@ -756,12 +756,12 @@ extension ${Self} : Arithmetic {
 }
 
 @_transparent
-public prefix func +(x: ${Self}) -> ${Self} {
+public prefix func + (x: ${Self}) -> ${Self} {
   return x
 }
 
 @_transparent
-public prefix func -(x: ${Self}) -> ${Self} {
+public prefix func - (x: ${Self}) -> ${Self} {
   return ${Self}(_bits: Builtin.fneg_FPIEEE${bits}(x._value))
 }
 
@@ -838,42 +838,42 @@ extension ${Self} {
 //  definitions in the standard lib, or both.
 
 @_transparent
-public func +(lhs: ${Self}, rhs: ${Self}) -> ${Self} {
+public func + (lhs: ${Self}, rhs: ${Self}) -> ${Self} {
   return lhs.adding(rhs)
 }
 
 @_transparent
-public func -(lhs: ${Self}, rhs: ${Self}) -> ${Self} {
+public func - (lhs: ${Self}, rhs: ${Self}) -> ${Self} {
   return lhs.subtracting(rhs)
 }
 
 @_transparent
-public func *(lhs: ${Self}, rhs: ${Self}) -> ${Self} {
+public func * (lhs: ${Self}, rhs: ${Self}) -> ${Self} {
   return lhs.multiplied(by: rhs)
 }
 
 @_transparent
-public func /(lhs: ${Self}, rhs: ${Self}) -> ${Self} {
+public func / (lhs: ${Self}, rhs: ${Self}) -> ${Self} {
   return lhs.divided(by: rhs)
 }
 
 @_transparent
-public func +=(lhs: inout ${Self}, rhs: ${Self}) {
+public func += (lhs: inout ${Self}, rhs: ${Self}) {
   lhs.add(rhs)
 }
 
 @_transparent
-public func -=(lhs: inout ${Self}, rhs: ${Self}) {
+public func -= (lhs: inout ${Self}, rhs: ${Self}) {
   lhs.subtract(rhs)
 }
 
 @_transparent
-public func *=(lhs: inout ${Self}, rhs: ${Self}) {
+public func *= (lhs: inout ${Self}, rhs: ${Self}) {
   lhs.multiply(by: rhs)
 }
 
 @_transparent
-public func /=(lhs: inout ${Self}, rhs: ${Self}) {
+public func /= (lhs: inout ${Self}, rhs: ${Self}) {
   lhs.divide(by: rhs)
 }
 
@@ -908,38 +908,38 @@ extension ${Self} : Strideable {
 
 @_transparent
 @available(*, unavailable, message: "Use truncatingRemainder instead")
-public func %(lhs: ${Self}, rhs: ${Self}) -> ${Self} {
+public func % (lhs: ${Self}, rhs: ${Self}) -> ${Self} {
   fatalError("% is not available.")
 }
 
 @_transparent
 @available(*, unavailable, message: "Use formTruncatingRemainder instead")
-public func %=(lhs: inout ${Self}, rhs: ${Self}) {
+public func %= (lhs: inout ${Self}, rhs: ${Self}) {
   fatalError("%= is not available.")
 }
 
 @_transparent
 @available(*, unavailable, message: "use += 1")
 @discardableResult
-public prefix func ++(rhs: inout ${Self}) -> ${Self} {
+public prefix func ++ (rhs: inout ${Self}) -> ${Self} {
   fatalError("++ is not available")
 }
 @_transparent
 @available(*, unavailable, message: "use -= 1")
 @discardableResult
-public prefix func --(rhs: inout ${Self}) -> ${Self} {
+public prefix func -- (rhs: inout ${Self}) -> ${Self} {
   fatalError("-- is not available")
 }
 @_transparent
 @available(*, unavailable, message: "use += 1")
 @discardableResult
-public postfix func ++(lhs: inout ${Self}) -> ${Self} {
+public postfix func ++ (lhs: inout ${Self}) -> ${Self} {
   fatalError("++ is not available")
 }
 @_transparent
 @available(*, unavailable, message: "use -= 1")
 @discardableResult
-public postfix func --(lhs: inout ${Self}) -> ${Self} {
+public postfix func -- (lhs: inout ${Self}) -> ${Self} {
   fatalError("-- is not available")
 }
 

stdlib/public/core/Hashable.swift

@@ -59,7 +59,7 @@
 ///             return x.hashValue ^ y.hashValue
 ///         }
 ///
-///         static func ==(lhs: GridPoint, rhs: GridPoint) -> Bool {
+///         static func == (lhs: GridPoint, rhs: GridPoint) -> Bool {
 ///             return lhs.x == rhs.x && lhs.y == rhs.y
 ///         }
 ///     }

stdlib/public/core/HashedCollections.swift.gyb

@@ -4548,7 +4548,7 @@ internal struct _Cocoa${Self}Index : Comparable {
 }
 
 extension _Cocoa${Self}Index {
-  internal static func ==(
+  internal static func == (
     lhs: _Cocoa${Self}Index,
     rhs: _Cocoa${Self}Index
   ) -> Bool {
@@ -4560,7 +4560,7 @@ extension _Cocoa${Self}Index {
     return lhs.currentKeyIndex == rhs.currentKeyIndex
   }
 
-  internal static func <(
+  internal static func < (
     lhs: _Cocoa${Self}Index,
     rhs: _Cocoa${Self}Index
   ) -> Bool {

stdlib/public/core/HeapBuffer.swift

@@ -220,7 +220,7 @@ struct _HeapBuffer<Value, Element> : Equatable {
 
 // HeapBuffers are equal when they reference the same buffer
 public // @testable
-func == <Value, Element> (
+func == <Value, Element>(
   lhs: _HeapBuffer<Value, Element>,
   rhs: _HeapBuffer<Value, Element>) -> Bool {
   return lhs._nativeObject == rhs._nativeObject

stdlib/public/core/Index.swift

@@ -17,25 +17,25 @@ public protocol _Incrementable : Equatable {}
 
 @available(*, unavailable, message: "Use \'-= 1\' or call collection.prior(Index)")
 @discardableResult
-public prefix func -- <T : _Incrementable> (i: inout T) -> T {
+public prefix func -- <T : _Incrementable>(i: inout T) -> T {
   Builtin.unreachable()
 }
 
 @available(*, unavailable, message: "Use \'-= 1\' or call collection.prior(Index)")
 @discardableResult
-public postfix func -- <T : _Incrementable> (i: inout T) -> T {
+public postfix func -- <T : _Incrementable>(i: inout T) -> T {
   Builtin.unreachable()
 }
 
 @available(*, unavailable, message: "Use \'+= 1\' or call 'collection.index(after: Index)")
 @discardableResult
-public prefix func ++ <T : _Incrementable> (i: inout T) -> T {
+public prefix func ++ <T : _Incrementable>(i: inout T) -> T {
   Builtin.unreachable()
 }
 
 @available(*, unavailable, message: "Use \'+= 1\' or call 'collection.index(after: Index)")
 @discardableResult
-public postfix func ++ <T : _Incrementable> (i: inout T) -> T {
+public postfix func ++ <T : _Incrementable>(i: inout T) -> T {
   Builtin.unreachable()
 }
 

stdlib/public/core/Integers.swift.gyb

@@ -175,7 +175,7 @@ public func ${x.operator}= <T: ${Protocol}>(lhs: inout T, rhs: T) {
 % end
 
 @_transparent
-public prefix func -<T: SignedArithmetic>(x: T) -> T {
+public prefix func - <T: SignedArithmetic>(x: T) -> T {
   return x.negated()
 }