nonisolated pattern matching

Author: swhitty

FlyingFox/Sources/HTTPRoute.swift

@@ -194,9 +194,15 @@ public extension HTTPRoute {
         fatalError()
     }
 
+#if compiler(>=6.2)
+    nonisolated(nonsending) static func ~= (route: HTTPRoute, request: HTTPRequest) async -> Bool {
+        await route.patternMatch(request: request)
+    }
+#else
     static func ~= (route: HTTPRoute, request: HTTPRequest) async -> Bool {
         await route.patternMatch(request: request)
     }
+#endif
 }
 
 private extension HTTPRoute {
@@ -224,13 +230,23 @@ private extension HTTPRoute {
         return nil
     }
 
+#if compiler(>=6.2)
+    nonisolated(nonsending) func patternMatch(request: HTTPRequest) async -> Bool {
+        guard patternMatch(query: request.query),
+              patternMatch(headers: request.headers),
+              await patternMatch(body: request.bodySequence) else { return false }
+
+        return patternMatch(method: request.method, path: request.path)
+    }
+#else
     func patternMatch(request: HTTPRequest) async -> Bool {
         guard patternMatch(query: request.query),
               patternMatch(headers: request.headers),
               await patternMatch(body: request.bodySequence) else { return false }
 
         return patternMatch(method: request.method, path: request.path)
     }
+#endif
 
     func patternMatch(method: HTTPMethod, path: String) -> Bool {
         guard self.methods.contains(method) else {
@@ -265,6 +281,22 @@ private extension HTTPRoute {
         }
     }
 
+#if compiler(>=6.2)
+    nonisolated(nonsending) func patternMatch(body request: HTTPBodySequence) async -> Bool {
+        guard let body = body else { return true }
+
+        guard request.canReplay else {
+            // body is large and can only be iterated one-time only so should not match it
+            return false
+        }
+
+        do {
+            return try await body.evaluate(request.get())
+        } catch {
+            return false
+        }
+    }
+#else
     func patternMatch(body request: HTTPBodySequence) async -> Bool {
         guard let body = body else { return true }
 
@@ -279,6 +311,7 @@ private extension HTTPRoute {
             return false
         }
     }
+#endif
 
     static func components(for target: String) -> (
         methods: Set<HTTPMethod>,

FlyingFox/Sources/Handlers/RoutedHTTPHandler.swift

@@ -81,10 +81,12 @@ public struct RoutedHTTPHandler: HTTPHandler, Sendable {
     public func handleRequest(_ request: HTTPRequest) async throws -> HTTPResponse {
         for entry in handlers  {
             do {
-                if await entry.route ~= request {
-                    return try await HTTPRequest.$matchedRoute.withValue(entry.route) {
-                        return try await entry.handler.handleRequest(request)
-                    }
+                if let response = try await Self.handleMatchedRequest(
+                    request,
+                    to: entry.route,
+                    handler: entry.handler.handleRequest
+                ) {
+                    return response
                 }
             } catch is HTTPUnhandledError {
                 continue
@@ -136,7 +138,23 @@ public extension RoutedHTTPHandler {
     }
 }
 
-#if compiler(>=6.0)
+#if compiler(>=6.2)
+public extension RoutedHTTPHandler {
+
+    nonisolated(nonsending) static func handleMatchedRequest(
+        _ request: HTTPRequest,
+        to route: HTTPRoute,
+        handler: (HTTPRequest) async throws -> HTTPResponse
+    ) async throws -> HTTPResponse? {
+        if await route ~= request {
+            return try await HTTPRequest.$matchedRoute.withValue(route) {
+                return try await handler(request)
+            }
+        }
+        return nil
+    }
+}
+#elseif compiler(>=6.0)
 public extension RoutedHTTPHandler {
 
     static func handleMatchedRequest(