Some more spanification

Author: fboemer

.github/workflows/ci.yml

@@ -25,7 +25,7 @@ jobs:
       api_breakage_check_enabled: false
       # swift:6.2-noble leads to issues with Snippets
       # e.g. https://github.com/apple/swift-homomorphic-encryption/actions/runs/18144503507/job/51643132814#step:5:1087
-      docs_check_container_image: swift:6.1-noble
+      docs_check_container_image: swift:6.2.2-noble
       format_check_enabled: false
   tests:
     name: swifttests

.spi.yml

@@ -12,4 +12,4 @@ builder:
         - PNNSProcessDatabase
         - PrivateInformationRetrieval
         - PrivateNearestNeighborSearch
-      swift_version: 6.0
+      swift_version: 6.2

.swiftformat

@@ -8,4 +8,4 @@
 --nospaceoperators ..<, ...
 --ranges no-space
 --self init-only
---swiftversion 6.0
+--swiftversion 6.2

Package.swift

@@ -341,6 +341,6 @@ if enableDocCPlugin {
 // Set the minimum macOS version for the package
 #if canImport(Darwin)
 package.platforms = [
-    .macOS(.v26), // Constrained by UInt128 support
+    .macOS(.v26), // Constrained by use of Span
 ]
 #endif

README.md

@@ -155,7 +155,7 @@ We'd like this package to quickly embrace Swift language and toolchain improveme
 Developing Swift Homomorphic Encryption requires:
 * [Nick Lockwood SwiftFormat](https://github.com/nicklockwood/SwiftFormat), 0.58.6
 * [pre-commit](https://pre-commit.com)
-* [swift-format](https://github.com/swiftlang/swift-format), 600.0.0
+* [swift-format](https://github.com/swiftlang/swift-format), 602.0.0
 * [swift-protobuf](https://github.com/apple/swift-protobuf), 1.31.1
 * [SwiftLint](https://github.com/realm/SwiftLint), 0.62.2
 

Sources/HomomorphicEncryption/Array2d.swift

@@ -76,35 +76,36 @@ public struct Array2d<T: Equatable & AdditiveArithmetic & Sendable>: Equatable,
             columnCount: columnCount)
     }
 
-    /// Provides scoped access to the underlying buffer storing the array's data.
+    /// Provides scoped access to the underlying buffer storing the array's data using a Span.
     ///
     /// Use this method when you need temporary read-only access to the array's contiguous storage.
-    /// The buffer pointer is only valid for the duration of the closure's execution.
+    /// The Span is only valid for the duration of the closure's execution.
     ///
-    /// - Parameter body: A closure that takes an `UnsafeBufferPointer` to the array's data.
-    ///   The buffer pointer argument is valid only for the duration of the closure's execution.
+    /// - Parameter body: A closure that takes a `Span<T>` to the array's data.
+    ///   The Span argument is valid only for the duration of the closure's execution.
     /// - Returns: The return value of the `body` closure.
     /// - Throws: Rethrows any error thrown by the `body` closure.
-    public func withUnsafeData<Return>(_ body: (UnsafeBufferPointer<T>) throws -> Return) rethrows -> Return {
-        try data.withUnsafeBufferPointer { pointer in
-            try body(pointer)
-        }
+    @inlinable
+    public func withDataSpan<Return>(_ body: (Span<T>) throws -> Return) rethrows -> Return {
+        try body(data.span)
     }
 
     /// Provides scoped access to the underlying buffer storing the array's data for mutation.
     ///
     /// Use this method when you need temporary read-write access to the array's contiguous storage.
-    /// The buffer pointer is only valid for the duration of the closure's execution.
+    /// The MutableSpan is only valid for the duration of the closure's execution.
     ///
-    /// - Parameter body: A closure that takes an `UnsafeMutableBufferPointer` to the array's data.
-    ///   The buffer pointer argument is valid only for the duration of the closure's execution.
+    /// - Parameter body: A closure that takes a `MutableSpan<T>` to the array's data.
+    ///   The MutableSpan argument is valid only for the duration of the closure's execution.
     /// - Returns: The return value of the `body` closure.
     /// - Throws: Rethrows any error thrown by the `body` closure.
-    public mutating func withUnsafeMutableData<Return>(_ body: (UnsafeMutableBufferPointer<T>) throws
-        -> Return) rethrows -> Return
+    @inlinable
+    public mutating func withMutableDataSpan<Return>(_ body: (inout MutableSpan<T>) throws -> Return) rethrows
+        -> Return
     {
-        try data.withUnsafeMutableBufferPointer { pointer in
-            try body(pointer)
+        try data.withUnsafeMutableBufferPointer { buffer in
+            var span = buffer.mutableSpan
+            return try body(&span)
         }
     }
 }

Sources/HomomorphicEncryption/CrtComposer.swift

@@ -87,7 +87,7 @@ public struct _CrtComposer<T: ScalarType>: Sendable {
             for column in 0..<data.columnCount {
                 let tmp = V(inversePuncturedProduct.multiplyMod(data[
                     row,
-                    column
+                    column,
                 ]))
                 let addend = tmp &* puncturedProduct
                 products[column] = products[column].addMod(addend, modulus: q)

Sources/HomomorphicEncryption/PolyRq/PolyRq.swift

@@ -148,7 +148,7 @@ extension PolyRq {
         lhs.validateMetadataEquality(with: rhs)
 
         var lhsData = lhs.data.data.mutableSpan
-        var rhsData = rhs.data.data.span
+        let rhsData = rhs.data.data.span
         for (rnsIndex, modulus) in rhs.moduli.enumerated() {
             for index in rhs.polyIndices(rnsIndex: rnsIndex) {
                 lhsData[index] = lhsData[index].addMod(rhsData[index], modulus: modulus)
@@ -298,16 +298,13 @@ extension PolyRq {
     @inlinable
     public static prefix func - (_ poly: Self) -> Self {
         var result = Self.zero(context: poly.context)
-        result.data.data.withUnsafeMutableBufferPointer { resultData in
-            poly.data.data.withUnsafeBufferPointer { rhsData in
-                for (rnsIndex, modulus) in poly.moduli.enumerated() {
-                    for index in poly.polyIndices(rnsIndex: rnsIndex) {
-                        resultData[index] = rhsData[index].negateMod(modulus: modulus)
-                    }
-                }
+        var resultData = result.data.data.mutableSpan
+        let rhsData = poly.data.data.span
+        for (rnsIndex, modulus) in poly.moduli.enumerated() {
+            for index in poly.polyIndices(rnsIndex: rnsIndex) {
+                resultData[index] = rhsData[index].negateMod(modulus: modulus)
             }
         }
-
         return result
     }
 

Tests/HomomorphicEncryptionTests/Array2dTests.swift

@@ -186,29 +186,27 @@ struct Array2dTests {
     }
 
     @Test
-    func withUnsafeData() {
+    func withDataSpan() {
         let data = [Int](0..<32)
         let array = Array2d(data: data, rowCount: 4, columnCount: 8)
-        array.withUnsafeData { dataPointer in
-            array.data.withUnsafeBufferPointer { expectedDataPointer in
-                #expect(dataPointer.baseAddress == expectedDataPointer.baseAddress)
+        var sum = 0
+        array.withDataSpan { span in
+            for index in span.indices {
+                sum += span[index]
             }
         }
+        #expect(sum == array.data.sum())
     }
 
     @Test
-    func withUnsafeMutableData() throws {
+    func withMutableDataSpan() {
         let data = [Int](0..<32)
         var array = Array2d(data: data, rowCount: 4, columnCount: 8)
-        // For the comparison we need 'mutable' pointers of the same type.
-        // But, `withUnsafe*` methods need exclusive ownership of the pointer.
-        let expectedBaseAddress = try #require(
-            array.data.withUnsafeMutableBufferPointer { buffer in
-                buffer.baseAddress
-            },
-            "Expected a valid base address")
-        array.withUnsafeMutableData { dataPointer in
-            #expect(dataPointer.baseAddress == expectedBaseAddress)
+        array.withMutableDataSpan { span in
+            for index in span.indices {
+                span[index] += 1
+            }
         }
+        #expect(array.data == [Int](1..<33))
     }
 }