swhitty · October 14, 2025 15:20 · Jun 3, 2025 · Jun 3, 2025 · Jun 3, 2025 · Jun 3, 2025
diff --git a/Mutex.swift b/Mutex.swift
@@ -23,9 +23,9 @@ public struct Mutex<Value: ~Copyable>: @unchecked Sendable, ~Copyable {
         return try body(&storage.value)
     }
 
-    public borrowing func withLockIfAvailable<Result, E>(
+    public borrowing func withLockIfAvailable<Result, E: Error>(
         _ body: (inout sending Value) throws(E) -> sending Result
-    ) throws(E) -> sending Result? where E: Error {
+    ) throws(E) -> sending Result? {
         guard lock.lockIfAvailable() else { return nil }
         defer { lock.unlock() }
         return try body(&storage.value)

diff --git a/Mutex.swift b/Mutex.swift
@@ -5,8 +5,8 @@
 import struct os.OSAllocatedUnfairLock
 
 // Backports the Swift 6.0 Mutex API
-@available(iOS, introduced: 16.0, deprecated: 18.0, message: "use Mutex from Synchronization module included with Swift 6")
-@available(macOS, introduced: 13.0, deprecated: 15.0, message: "use Mutex from Synchronization module included with Swift 6")
+@available(iOS, introduced: 16.0, deprecated: 18.0, message: "use Mutex from Synchronization module")
+@available(macOS, introduced: 13.0, deprecated: 15.0, message: "use Mutex from Synchronization module")
 public struct Mutex<Value: ~Copyable>: @unchecked Sendable, ~Copyable {
     private let lock = OSAllocatedUnfairLock()
     private let storage: Storage

diff --git a/Mutex.swift b/Mutex.swift
@@ -31,7 +31,7 @@ public struct Mutex<Value: ~Copyable>: @unchecked Sendable, ~Copyable {
         return try body(&storage.value)
     }
 
-    final class Storage {
+    private final class Storage {
         var value: Value
 
         init(_ initialValue: consuming Value) {

diff --git a/Mutex.swift b/Mutex.swift
@@ -1,55 +1,41 @@
 // Backports the Swift 6 type Mutex<Value> to all Darwin platforms via OSAllocatedUnfairLock.
 // Lightweight version of https://github.com/swhitty/swift-mutex
 // Feel free to use any part of this gist.
-// Note: Value: ~Copyable are not supported
 
 import struct os.OSAllocatedUnfairLock
 
+// Backports the Swift 6.0 Mutex API
 @available(iOS, introduced: 16.0, deprecated: 18.0, message: "use Mutex from Synchronization module included with Swift 6")
 @available(macOS, introduced: 13.0, deprecated: 15.0, message: "use Mutex from Synchronization module included with Swift 6")
-public struct Mutex<Value>: @unchecked Sendable, ~Copyable {
-    let lock: OSAllocatedUnfairLock<Value>
+public struct Mutex<Value: ~Copyable>: @unchecked Sendable, ~Copyable {
+    private let lock = OSAllocatedUnfairLock()
+    private let storage: Storage
 
     public init(_ initialValue: consuming sending Value) {
-        self.lock = OSAllocatedUnfairLock(uncheckedState: initialValue)
+        self.storage = Storage(initialValue)
     }
 
     public borrowing func withLock<Result, E: Error>(
         _ body: (inout sending Value) throws(E) -> sending Result
     ) throws(E) -> sending Result {
-        do {
-            return try lock.withLockUnchecked { value in
-                nonisolated(unsafe) var copy = value
-                defer { value = copy }
-                return try Transferring(body(&copy))
-            }.value
-        } catch let error as E {
-            throw error
-        } catch {
-            preconditionFailure("cannot occur")
-        }
+        lock.lock()
+        defer { lock.unlock() }
+        return try body(&storage.value)
     }
 
     public borrowing func withLockIfAvailable<Result, E>(
         _ body: (inout sending Value) throws(E) -> sending Result
     ) throws(E) -> sending Result? where E: Error {
-        do {
-            return try lock.withLockIfAvailableUnchecked { value in
-                nonisolated(unsafe) var copy = value
-                defer { value = copy }
-                return try Transferring(body(&copy))
-            }?.value
-        } catch let error as E {
-            throw error
-        } catch {
-            preconditionFailure("cannot occur")
-        }
+        guard lock.lockIfAvailable() else { return nil }
+        defer { lock.unlock() }
+        return try body(&storage.value)
     }
-}
 
-private struct Transferring<T> {
-    nonisolated(unsafe) var value: T
-    init(_ value: T) {
-        self.value = value
+    final class Storage {
+        var value: Value
+
+        init(_ initialValue: consuming Value) {
+            self.value = initialValue
+        }
     }
 }
diff --git a/Mutex.swift b/Mutex.swift
@@ -1,13 +1,13 @@
-// Backports the Swift 6 type Mutex<Value> to Swift 5 and all Darwin platforms via OSAllocatedUnfairLock.
+// Backports the Swift 6 type Mutex<Value> to all Darwin platforms via OSAllocatedUnfairLock.
 // Lightweight version of https://github.com/swhitty/swift-mutex
 // Feel free to use any part of this gist.
-// Note: ~Copyable are not supported
+// Note: Value: ~Copyable are not supported
 
-#if compiler(>=6)
+import struct os.OSAllocatedUnfairLock
 
 @available(iOS, introduced: 16.0, deprecated: 18.0, message: "use Mutex from Synchronization module included with Swift 6")
 @available(macOS, introduced: 13.0, deprecated: 15.0, message: "use Mutex from Synchronization module included with Swift 6")
-public struct Mutex<Value>: @unchecked Sendable {
+public struct Mutex<Value>: @unchecked Sendable, ~Copyable {
     let lock: OSAllocatedUnfairLock<Value>
 
     public init(_ initialValue: consuming sending Value) {
@@ -52,33 +52,4 @@ private struct Transferring<T> {
     init(_ value: T) {
         self.value = value
     }
-}
-
-#else
-
-@available(macOS 13.0, iOS 16.0, *)
-public struct Mutex<Value>: @unchecked Sendable {
-    let lock: OSAllocatedUnfairLock<Value>
-
-    public init(_ initialValue: consuming Value) {
-        self.lock = OSAllocatedUnfairLock(uncheckedState: initialValue)
-    }
-
-    public borrowing func withLock<Result>(
-        _ body: (inout Value) throws -> Result
-    ) rethrows -> Result {
-        try lock.withLockUnchecked {
-            return try body(&$0)
-        }
-    }
-
-    public borrowing func withLockIfAvailable<Result>(
-        _ body: (inout Value) throws -> Result
-    ) rethrows -> Result? {
-        try lock.withLockIfAvailableUnchecked {
-            return try body(&$0)
-        }
-    }
-}
-
-#endif
+}
diff --git a/Mutex.swift b/Mutex.swift
@@ -1,6 +1,7 @@
-// Backports the Swift 6 type Mutex<Value> to Swift 5 and all Darwin platforms via OSAllocatedUnfairLock
+// Backports the Swift 6 type Mutex<Value> to Swift 5 and all Darwin platforms via OSAllocatedUnfairLock.
 // Lightweight version of https://github.com/swhitty/swift-mutex
 // Feel free to use any part of this gist.
+// Note: ~Copyable are not supported
 
 #if compiler(>=6)
 

diff --git a/Mutex.swift b/Mutex.swift
@@ -5,7 +5,7 @@
 #if compiler(>=6)
 
 @available(iOS, introduced: 16.0, deprecated: 18.0, message: "use Mutex from Synchronization module included with Swift 6")
-@available(macOS,introduced: 13.0, deprecated: 15.0, message: "use Mutex from Synchronization module included with Swift 6")
+@available(macOS, introduced: 13.0, deprecated: 15.0, message: "use Mutex from Synchronization module included with Swift 6")
 public struct Mutex<Value>: @unchecked Sendable {
     let lock: OSAllocatedUnfairLock<Value>
 

diff --git a/Mutex.swift b/Mutex.swift
@@ -1,4 +1,4 @@
-// Backports the Swift 6 type Mutex<Value> to Swift 5 and all Darwin platforms with OSAllocatedUnfairLock
+// Backports the Swift 6 type Mutex<Value> to Swift 5 and all Darwin platforms via OSAllocatedUnfairLock
 // Lightweight version of https://github.com/swhitty/swift-mutex
 // Feel free to use any part of this gist.
 

diff --git a/Mutex.swift b/Mutex.swift
@@ -3,6 +3,7 @@
 // Feel free to use any part of this gist.
 
 #if compiler(>=6)
+
 @available(iOS, introduced: 16.0, deprecated: 18.0, message: "use Mutex from Synchronization module included with Swift 6")
 @available(macOS,introduced: 13.0, deprecated: 15.0, message: "use Mutex from Synchronization module included with Swift 6")
 public struct Mutex<Value>: @unchecked Sendable {
@@ -51,14 +52,15 @@ private struct Transferring<T> {
         self.value = value
     }
 }
+
 #else
-@available(iOS, introduced: 16.0, deprecated: 18.0, message: "use Mutex from Synchronization module included with Swift 6")
-@available(macOS,introduced: 13.0, deprecated: 15.0, message: "use Mutex from Synchronization module included with Swift 6")
+
+@available(macOS 13.0, iOS 16.0, *)
 public struct Mutex<Value>: @unchecked Sendable {
     let lock: OSAllocatedUnfairLock<Value>
 
     public init(_ initialValue: consuming Value) {
-        self.lock = AllocatedLock(uncheckedState: initialValue)
+        self.lock = OSAllocatedUnfairLock(uncheckedState: initialValue)
     }
 
     public borrowing func withLock<Result>(
@@ -77,4 +79,5 @@ public struct Mutex<Value>: @unchecked Sendable {
         }
     }
 }
+
 #endif
diff --git a/Mutex.swift b/Mutex.swift
@@ -0,0 +1,80 @@
+// Backports the Swift 6 type Mutex<Value> to Swift 5 and all Darwin platforms with OSAllocatedUnfairLock
+// Lightweight version of https://github.com/swhitty/swift-mutex
+// Feel free to use any part of this gist.
+
+#if compiler(>=6)
+@available(iOS, introduced: 16.0, deprecated: 18.0, message: "use Mutex from Synchronization module included with Swift 6")
+@available(macOS,introduced: 13.0, deprecated: 15.0, message: "use Mutex from Synchronization module included with Swift 6")
+public struct Mutex<Value>: @unchecked Sendable {
+    let lock: OSAllocatedUnfairLock<Value>
+
+    public init(_ initialValue: consuming sending Value) {
+        self.lock = OSAllocatedUnfairLock(uncheckedState: initialValue)
+    }
+
+    public borrowing func withLock<Result, E: Error>(
+        _ body: (inout sending Value) throws(E) -> sending Result
+    ) throws(E) -> sending Result {
+        do {
+            return try lock.withLockUnchecked { value in
+                nonisolated(unsafe) var copy = value
+                defer { value = copy }
+                return try Transferring(body(&copy))
+            }.value
+        } catch let error as E {
+            throw error
+        } catch {
+            preconditionFailure("cannot occur")
+        }
+    }
+
+    public borrowing func withLockIfAvailable<Result, E>(
+        _ body: (inout sending Value) throws(E) -> sending Result
+    ) throws(E) -> sending Result? where E: Error {
+        do {
+            return try lock.withLockIfAvailableUnchecked { value in
+                nonisolated(unsafe) var copy = value
+                defer { value = copy }
+                return try Transferring(body(&copy))
+            }?.value
+        } catch let error as E {
+            throw error
+        } catch {
+            preconditionFailure("cannot occur")
+        }
+    }
+}
+
+private struct Transferring<T> {
+    nonisolated(unsafe) var value: T
+    init(_ value: T) {
+        self.value = value
+    }
+}
+#else
+@available(iOS, introduced: 16.0, deprecated: 18.0, message: "use Mutex from Synchronization module included with Swift 6")
+@available(macOS,introduced: 13.0, deprecated: 15.0, message: "use Mutex from Synchronization module included with Swift 6")
+public struct Mutex<Value>: @unchecked Sendable {
+    let lock: OSAllocatedUnfairLock<Value>
+
+    public init(_ initialValue: consuming Value) {
+        self.lock = AllocatedLock(uncheckedState: initialValue)
+    }
+
+    public borrowing func withLock<Result>(
+        _ body: (inout Value) throws -> Result
+    ) rethrows -> Result {
+        try lock.withLockUnchecked {
+            return try body(&$0)
+        }
+    }
+
+    public borrowing func withLockIfAvailable<Result>(
+        _ body: (inout Value) throws -> Result
+    ) rethrows -> Result? {
+        try lock.withLockIfAvailableUnchecked {
+            return try body(&$0)
+        }
+    }
+}
+#endif