Refactor trivial expressions using swift expressions.

See https://github.com/swiftlang/swift-evolution/blob/main/proposals/0380-if-switch-expressions.md
Cornucopia-Swift · Jul 17, 2024 · ed9a0a6 · ed9a0a6
1 parent 5ee2af0
commit ed9a0a6
Show file tree

Hide file tree

Showing 11 changed files with 76 additions and 100 deletions.
diff --git a/Sources/CornucopiaCore/Extensions/Bool/Bool+Random.swift b/Sources/CornucopiaCore/Extensions/Bool/Bool+Random.swift
@@ -6,18 +6,18 @@ public extension Bool {
     /// Returns `true` with the specified `probability`, else `false`.
     static func CC_true(withProbabilityOf probability: Double = 0.5) -> Self {
         switch probability {
-            case let p where p <= 0: return false
-            case let p where p >= 1: return true
-            default:                 return Double.random(in: 0...1) <= probability
+            case let p where p <= 0: false
+            case let p where p >= 1: true
+            default:                 Double.random(in: 0...1) <= probability
         }
     }
 
     /// Returns `false` with the specified `probability`, else `true`.
     static func CC_false(withProbabilityOf probability: Double = 0.5) -> Self {
         switch probability {
-            case let p where p <= 0: return true
-            case let p where p >= 1: return false
-            default:                 return Double.random(in: 0...1) > probability
+            case let p where p <= 0: true
+            case let p where p >= 1: false
+            default:                 Double.random(in: 0...1) > probability
         }
     }
 }
diff --git a/...ornucopiaCore/Extensions/CoreLocation/CLAuthorizationStatus+CustomStringConvertible.swift b/...ornucopiaCore/Extensions/CoreLocation/CLAuthorizationStatus+CustomStringConvertible.swift
@@ -8,12 +8,12 @@ extension CLAuthorizationStatus: CustomStringConvertible {
 
     public var description: String {
         switch self {
-        case .authorizedAlways:    return ".authorizedAlways"
-        case .authorizedWhenInUse: return ".authorizedWhenInUse"
-        case .denied:              return ".denied"
-        case .notDetermined:       return ".notDetermined"
-        case .restricted:          return ".restricted"
-        @unknown default:          return ".\(rawValue)"
+            case .authorizedAlways:    ".authorizedAlways"
+            case .authorizedWhenInUse: ".authorizedWhenInUse"
+            case .denied:              ".denied"
+            case .notDetermined:       ".notDetermined"
+            case .restricted:          ".restricted"
+            @unknown default:          ".\(rawValue)"
         }
     }
 }

diff --git a/Sources/CornucopiaCore/Extensions/DispatchTimeInterval/DispatchTimeInterval+Duration.swift b/Sources/CornucopiaCore/Extensions/DispatchTimeInterval/DispatchTimeInterval+Duration.swift
@@ -10,18 +10,12 @@ public extension DispatchTimeInterval {
     var CC_duration: Duration {
 
         switch self {
-            case .seconds(let value):
-                return Duration.seconds(value)
-            case .milliseconds(let value):
-                return Duration.milliseconds(value)
-            case .microseconds(let value):
-                return Duration.microseconds(value)
-            case .nanoseconds(let value):
-                return Duration.nanoseconds(value)
-            case .never:
-                return Duration.zero
-            @unknown default:
-                fatalError("not yet implemented")
+            case .seconds(let value):      Duration.seconds(value)
+            case .milliseconds(let value): Duration.milliseconds(value)
+            case .microseconds(let value): Duration.microseconds(value)
+            case .nanoseconds(let value):  Duration.nanoseconds(value)
+            case .never:                   Duration.zero
+            @unknown default:              fatalError("not yet implemented")
         }
     }
 }
diff --git a/...es/CornucopiaCore/Extensions/DispatchTimeInterval/DispatchTimeInterval+TimeInterval.swift b/...es/CornucopiaCore/Extensions/DispatchTimeInterval/DispatchTimeInterval+TimeInterval.swift
@@ -9,18 +9,12 @@ public extension DispatchTimeInterval {
     var CC_timeInterval: TimeInterval {
 
         switch self {
-            case .seconds(let value):
-                return Double(value)
-            case .milliseconds(let value):
-                return Double(value) / 1_000
-            case .microseconds(let value):
-                return Double(value) / 1_000_000
-            case .nanoseconds(let value):
-                return Double(value) / 1_000_000_000
-            case .never:
-                return Double.greatestFiniteMagnitude
-            @unknown default:
-                fatalError("not yet implemented")
+            case .seconds(let value):      Double(value)
+            case .milliseconds(let value): Double(value) / 1_000
+            case .microseconds(let value): Double(value) / 1_000_000
+            case .nanoseconds(let value):  Double(value) / 1_000_000_000
+            case .never:                   Double.greatestFiniteMagnitude
+            @unknown default:              fatalError("not yet implemented")
         }
     }
 }
diff --git a/Sources/CornucopiaCore/Extensions/Glibc/sockaddr+length.swift b/Sources/CornucopiaCore/Extensions/Glibc/sockaddr+length.swift
@@ -4,9 +4,9 @@ import Glibc
 extension sockaddr {
     var sa_len: Int {
         switch Int32(sa_family) {
-            case AF_INET: return MemoryLayout<sockaddr_in>.size
-            case AF_INET6: return MemoryLayout<sockaddr_in6>.size
-            default: return MemoryLayout<sockaddr_storage>.size // something else
+            case AF_INET:  MemoryLayout<sockaddr_in>.size
+            case AF_INET6: MemoryLayout<sockaddr_in6>.size
+            default:       MemoryLayout<sockaddr_storage>.size // something else
         }
     }
 }
@@ -15,9 +15,9 @@ extension sockaddr {
 extension sockaddr_in {
     var sin_len: Int {
         switch Int32(sa_family) {
-            case AF_INET: return MemoryLayout<sockaddr_in>.size
-            case AF_INET6: return MemoryLayout<sockaddr_in6>.size
-            default: return MemoryLayout<sockaddr_storage>.size // something else
+            case AF_INET:  MemoryLayout<sockaddr_in>.size
+            case AF_INET6: MemoryLayout<sockaddr_in6>.size
+            default:       MemoryLayout<sockaddr_storage>.size // something else
         }
     }
 }

diff --git a/Sources/CornucopiaCore/Extensions/Stream/Stream+CustomStringConvertible.swift b/Sources/CornucopiaCore/Extensions/Stream/Stream+CustomStringConvertible.swift
@@ -7,17 +7,17 @@ extension Stream.Status: CustomStringConvertible {
 
     @inlinable public var description: String {
         switch self {
-            case .notOpen: return "not open"
-            case .opening: return "opening"
-            case .open:    return "open"
-            case .reading: return "reading"
-            case .writing: return "writing"
-            case .atEnd:   return "eof"
-            case .closed:  return "closed"
-            case .error:   return "error"
+            case .notOpen: "not open"
+            case .opening: "opening"
+            case .open:    "open"
+            case .reading: "reading"
+            case .writing: "writing"
+            case .atEnd:   "eof"
+            case .closed:  "closed"
+            case .error:   "error"
             // Conditionally to fix an "unreachable" warning on Linux.
             #if canImport(ObjectiveC)
-            @unknown default: return "unknown"
+            @unknown default: "unknown"
             #endif
         }
     }

diff --git a/Sources/CornucopiaCore/Extensions/StringInterpolation/String+PrintableInterpolation.swift b/Sources/CornucopiaCore/Extensions/StringInterpolation/String+PrintableInterpolation.swift
@@ -47,14 +47,10 @@ public extension String.StringInterpolation {
         let substitutedElements: [String] = elements.map {
 
             switch $0 {
-                case Character("\r"):
-                    return "\\r"
-                case Character("\n"):
-                    return "\\n"
-                case Character("\t"):
-                    return "\\t"
-                default:
-                    return String($0)
+                case Character("\r"): "\\r"
+                case Character("\n"): "\\n"
+                case Character("\t"): "\\t"
+                default:              String($0)
             }
         }
         appendInterpolation(substitutedElements.joined())
@@ -68,11 +64,11 @@ public extension String.StringInterpolation {
         let substitutedElements: [String] = elements.map {
 
             let uint8 = UInt8($0)
-            switch uint8 {
-                case 0x09: return "\\t"
-                case 0x0A: return "\\n"
-                case 0x0D: return "\\r"
-                default: return String(UnicodeScalar(uint8))
+            return switch uint8 {
+                case 0x09: "\\t"
+                case 0x0A: "\\n"
+                case 0x0D: "\\r"
+                default:   String(UnicodeScalar(uint8))
             }
         }
         appendInterpolation(substitutedElements.joined())

diff --git a/Sources/CornucopiaCore/Logging/LogSink.swift b/Sources/CornucopiaCore/Logging/LogSink.swift
@@ -26,12 +26,12 @@ extension Cornucopia.Core {
 
         public var character: String {
             switch self {
-                case .trace:   return "T"
-                case .debug:   return "D"
-                case .info:    return "I"
-                case .notice:  return "N"
-                case .error:   return "E"
-                case .fault:   return "F"
+                case .trace:  "T"
+                case .debug:  "D"
+                case .info:   "I"
+                case .notice: "N"
+                case .error:  "E"
+                case .fault:  "F"
             }
         }
     }

diff --git a/Sources/CornucopiaCore/Logging/SysLogger.swift b/Sources/CornucopiaCore/Logging/SysLogger.swift
@@ -66,22 +66,14 @@ extension Cornucopia.Core {
 
         public func log(_ entry: LogEntry) {
 
-            let severity: Cornucopia.Core.SysLogEntry.Severity = {
-                switch entry.level {
-                    case .trace:
-                        return .debug
-                    case .debug:
-                        return .debug
-                    case .info:
-                        return .informational
-                    case .notice:
-                        return .warning
-                    case .error:
-                        return .error
-                    case .fault:
-                        return .error
-                }
-            }()
+            let severity: Cornucopia.Core.SysLogEntry.Severity = switch entry.level {
+                case .trace:  .debug
+                case .debug:  .debug
+                case .info:   .informational
+                case .notice: .warning
+                case .error:  .error
+                case .fault:  .error
+            }
 
             let sysLogEntry = SysLogEntry(facility: .local0, severity: severity, hostname: self.hostname, appname: self.appname, procid: "\(entry.thread)", msgid: entry.category, msg: entry.message)
             let formatted = self.udp ? sysLogEntry.formatted : sysLogEntry.frame

diff --git a/Sources/CornucopiaCore/Networking/HTTPStatusCodes.swift b/Sources/CornucopiaCore/Networking/HTTPStatusCodes.swift
@@ -101,13 +101,13 @@ public enum HTTPStatusCode: Int, Error {
     public var responseType: ResponseType {
         get {
             switch self.rawValue {
-            case ..<0: return .Internal
-            case 100..<200: return .Informational
-            case 200..<300: return .Success
-            case 300..<400: return .Redirection
-            case 400..<500: return .ClientError
-            case 500..<600: return .ServerError
-            default: return .Undefined
+                case ..<0:      .Internal
+                case 100..<200: .Informational
+                case 200..<300: .Success
+                case 300..<400: .Redirection
+                case 400..<500: .ClientError
+                case 500..<600: .ServerError
+                default:        .Undefined
             }
         }
     }

diff --git a/Sources/CornucopiaCore/Types/AnyValue.swift b/Sources/CornucopiaCore/Types/AnyValue.swift
@@ -41,13 +41,13 @@ public extension Cornucopia.Core {
 
         public var anyValue: Any {
             switch self {
-                case .string(let string): return string
-                case .bool(let bool): return bool
-                case .int(let int): return int
-                case .double(let double): return double
-                case .dictionary(let dict): return dict.CC_mappedValues { $0.anyValue }
-                case .array(let array): return array.map { $0.anyValue }
-                case .null: return NSNull()
+                case .string(let string):   string
+                case .bool(let bool):       bool
+                case .int(let int):         int
+                case .double(let double):   double
+                case .dictionary(let dict): dict.CC_mappedValues { $0.anyValue }
+                case .array(let array):     array.map { $0.anyValue }
+                case .null:                 NSNull()
             }
         }