diff --git a/Sources/ANKFullWidthKit/ANKFullWidth+Addition+Digit.swift b/Sources/ANKFullWidthKit/ANKFullWidth+Addition+Digit.swift index 40bdd7ec..f17e47fe 100644 --- a/Sources/ANKFullWidthKit/ANKFullWidth+Addition+Digit.swift +++ b/Sources/ANKFullWidthKit/ANKFullWidth+Addition+Digit.swift @@ -49,7 +49,7 @@ extension ANKFullWidth { let lhsWasLessThanZero: Bool = self.isLessThanZero let rhsWasLessThanZero: Bool = amount.isLessThanZero //=--------------------------------------= - let carry: Bool = self.withUnsafeMutableWordsPointer { LHS in + let carry: Bool = self.withUnsafeMutableWords { LHS in var index = LHS.startIndex var carry: Bool = LHS[index].addReportingOverflow(UInt(bitPattern: amount)) LHS.formIndex(after: &index) diff --git a/Sources/ANKFullWidthKit/ANKFullWidth+Bitwise.swift b/Sources/ANKFullWidthKit/ANKFullWidth+Bitwise.swift index 25c2c693..cdea4dc1 100644 --- a/Sources/ANKFullWidthKit/ANKFullWidth+Bitwise.swift +++ b/Sources/ANKFullWidthKit/ANKFullWidth+Bitwise.swift @@ -43,11 +43,11 @@ extension ANKFullWidth { //=------------------------------------------------------------------------= @inlinable public var byteSwapped: Self { - Self.fromUnsafeMutableWordsAllocation { NEXT in - self.withUnsafeWordsPointer { SELF in + Self.fromUnsafeMutableWords { RESULT in + self.withUnsafeWords { SELF in for index in SELF.indices { let word: UInt = SELF[index].byteSwapped - NEXT[SELF.lastIndex - index] = word + RESULT[RESULT.lastIndex &- index] = word } }} } diff --git a/Sources/ANKFullWidthKit/ANKFullWidth+Collection+Pointers.swift b/Sources/ANKFullWidthKit/ANKFullWidth+Collection+Pointers.swift index c544eecd..cf324589 100644 --- a/Sources/ANKFullWidthKit/ANKFullWidth+Collection+Pointers.swift +++ b/Sources/ANKFullWidthKit/ANKFullWidth+Collection+Pointers.swift @@ -224,9 +224,9 @@ extension ANKFullWidth { /// unchecked subscript access and wrapping index arithmetic. So, don't /// do stupid stuff. Understood? Cool. Let's go! /// - @_transparent public func withUnsafeWordsPointer( + @_transparent public func withUnsafeWords( _ body: (UnsafeWordsPointer) throws -> T) rethrows -> T { - try Swift.withUnsafePointer(to: self) { SELF in + try Swift.withUnsafePointer(to: self) { SELF in try SELF.withMemoryRebound(to: UInt.self, capacity: Self.count) { WORDS in try body(UnsafeWordsPointer(WORDS)) } @@ -239,7 +239,7 @@ extension ANKFullWidth { /// unchecked subscript access and wrapping index arithmetic. So, don't /// do stupid stuff. Understood? Cool. Let's go! /// - @_transparent public mutating func withUnsafeMutableWordsPointer( + @_transparent public mutating func withUnsafeMutableWords( _ body: (UnsafeMutableWordsPointer) throws -> T) rethrows -> T { try Swift.withUnsafeMutablePointer(to: &self) { SELF in try SELF.withMemoryRebound(to: UInt.self, capacity: Self.count) { WORDS in @@ -254,7 +254,7 @@ extension ANKFullWidth { /// unchecked subscript access and wrapping index arithmetic. So, don't /// do stupid stuff. Understood? Cool. Let's go! /// - @_transparent public static func fromUnsafeMutableWordsAllocation( + @_transparent public static func fromUnsafeMutableWords( _ body: (UnsafeMutableWordsPointer) throws -> Void) rethrows -> Self { try Swift.withUnsafeTemporaryAllocation(of: Self.self, capacity: 1) { BUFFER in let SELF = BUFFER.baseAddress.unsafelyUnwrapped diff --git a/Sources/ANKFullWidthKit/ANKFullWidth+Collection.swift b/Sources/ANKFullWidthKit/ANKFullWidth+Collection.swift index 4a4ff919..e72e29e4 100644 --- a/Sources/ANKFullWidthKit/ANKFullWidth+Collection.swift +++ b/Sources/ANKFullWidthKit/ANKFullWidth+Collection.swift @@ -82,8 +82,8 @@ extension ANKFullWidth { //=------------------------------------------------------------------------= @usableFromInline subscript(unchecked index: Int) -> UInt { - @_transparent _read { yield self.withUnsafeWordsPointer({ $0[index] /*------*/ }) } - @_transparent set { self.withUnsafeMutableWordsPointer({ $0[index] = newValue }) } + @_transparent _read { yield self.withUnsafeWords({ $0[index] /*------*/ }) } + @_transparent set { self.withUnsafeMutableWords({ $0[index] = newValue }) } } public subscript(index: Int) -> UInt { diff --git a/Sources/ANKFullWidthKit/ANKFullWidth+Complements.swift b/Sources/ANKFullWidthKit/ANKFullWidth+Complements.swift index 96d727eb..d2985f4c 100644 --- a/Sources/ANKFullWidthKit/ANKFullWidth+Complements.swift +++ b/Sources/ANKFullWidthKit/ANKFullWidth+Complements.swift @@ -40,7 +40,7 @@ extension ANKFullWidth { //=------------------------------------------------------------------------= @inlinable public mutating func formTwosComplement() { - self.withUnsafeMutableWordsPointer { SELF in + self.withUnsafeMutableWords { SELF in var carry: Bool = true for index: Int in SELF.indices { var word: UInt = ~SELF[index] diff --git a/Sources/ANKFullWidthKit/ANKFullWidth+Division+Digit.swift b/Sources/ANKFullWidthKit/ANKFullWidth+Division+Digit.swift index e98acf74..543540e9 100644 --- a/Sources/ANKFullWidthKit/ANKFullWidth+Division+Digit.swift +++ b/Sources/ANKFullWidthKit/ANKFullWidth+Division+Digit.swift @@ -122,7 +122,7 @@ extension ANKFullWidth where High == High.Magnitude { var quotient = self var remainder = UInt() //=--------------------------------------= - quotient.withUnsafeMutableWordsPointer { QUOTIENT in + quotient.withUnsafeMutableWords { QUOTIENT in //=----------------------------------= var quotientIndex: Int = QUOTIENT.endIndex //=----------------------------------= diff --git a/Sources/ANKFullWidthKit/ANKFullWidth+Division.swift b/Sources/ANKFullWidthKit/ANKFullWidth+Division.swift index bd148d56..fff6924b 100644 --- a/Sources/ANKFullWidthKit/ANKFullWidth+Division.swift +++ b/Sources/ANKFullWidthKit/ANKFullWidth+Division.swift @@ -178,7 +178,7 @@ extension ANKFullWidth where High == High.Magnitude { //=--------------------------------------= // Division //=--------------------------------------= - var quotient = Self(); quotient.withUnsafeMutableWordsPointer { QUOTIENT in + var quotient = Self(); quotient.withUnsafeMutableWords { QUOTIENT in var remainderIndex = remainder_.minLastIndex &+ 1 var quotientIndex = remainderIndex &- divisor_.minLastIndex let divisorLast0 = divisor[unchecked: divisor_.minLastIndex] @@ -188,7 +188,7 @@ extension ANKFullWidth where High == High.Magnitude { //=------------------------------= // Approximate Quotient Digit //=------------------------------= - var digit: UInt = remainder.withUnsafeWordsPointer { REMAINDER in + var digit: UInt = remainder.withUnsafeWords { REMAINDER in let remainderLast0 = REMAINDER[remainderIndex] REMAINDER.formIndex(before:/*-*/&remainderIndex) if remainderLast0 >= divisorLast0 { return UInt.max } diff --git a/Sources/ANKFullWidthKit/ANKFullWidth+Multiplication+Digit.swift b/Sources/ANKFullWidthKit/ANKFullWidth+Multiplication+Digit.swift index 6743d359..2bc67d1c 100644 --- a/Sources/ANKFullWidthKit/ANKFullWidth+Multiplication+Digit.swift +++ b/Sources/ANKFullWidthKit/ANKFullWidth+Multiplication+Digit.swift @@ -73,8 +73,8 @@ extension ANKFullWidth { let rhsIsLessThanZero: Bool = amount.isLessThanZero //=--------------------------------------= var high = UInt() - let low: Magnitude = self.withUnsafeWordsPointer { LHS in - Magnitude.fromUnsafeMutableWordsAllocation { LOW in + let low: Magnitude = self.withUnsafeWords { LHS in + Magnitude.fromUnsafeMutableWords { LOW in //=----------------------------------= let rhsWord = UInt(bitPattern: amount) var rhsIsLessThanZeroCarry = rhsIsLessThanZero diff --git a/Sources/ANKFullWidthKit/ANKFullWidth+Multiplication.swift b/Sources/ANKFullWidthKit/ANKFullWidth+Multiplication.swift index 1131251c..bc0eed12 100644 --- a/Sources/ANKFullWidthKit/ANKFullWidth+Multiplication.swift +++ b/Sources/ANKFullWidthKit/ANKFullWidth+Multiplication.swift @@ -94,9 +94,9 @@ extension ANKFullWidth { //=--------------------------------------= var product = DoubleWidth() //=--------------------------------------= - self .withUnsafeWordsPointer { LHS in - amount .withUnsafeWordsPointer { RHS in - product.withUnsafeMutableWordsPointer { PRODUCT in + self .withUnsafeWords { LHS in + amount .withUnsafeWords { RHS in + product.withUnsafeMutableWords { PRODUCT in //=----------------------------------= for lhsIndex: Int in LHS.indices { var carry: UInt = UInt() diff --git a/Sources/ANKFullWidthKit/ANKFullWidth+Numbers.swift b/Sources/ANKFullWidthKit/ANKFullWidth+Numbers.swift index 63f9bd48..590d0a85 100644 --- a/Sources/ANKFullWidthKit/ANKFullWidth+Numbers.swift +++ b/Sources/ANKFullWidthKit/ANKFullWidth+Numbers.swift @@ -272,7 +272,7 @@ extension ANKFullWidth { assert(sign == UInt.min || sign == UInt.max) //=--------------------------------------= var index = words.startIndex - let value = Self.fromUnsafeMutableWordsAllocation { VALUE in + let value = Self.fromUnsafeMutableWords { VALUE in //=----------------------------------= var valueIndex = VALUE.startIndex var wordsIndex = words.startIndex diff --git a/Sources/ANKFullWidthKit/ANKFullWidth+Shifts.swift b/Sources/ANKFullWidthKit/ANKFullWidth+Shifts.swift index 888f613e..1260d73d 100644 --- a/Sources/ANKFullWidthKit/ANKFullWidth+Shifts.swift +++ b/Sources/ANKFullWidthKit/ANKFullWidth+Shifts.swift @@ -66,8 +66,8 @@ extension ANKFullWidth { //=--------------------------------------= var next = Self() //=--------------------------------------= - next.withUnsafeMutableWordsPointer { NEXT in - self.withUnsafeWordsPointer { SELF in + next.withUnsafeMutableWords { NEXT in + self.withUnsafeWords { SELF in let a: Int = bits let b: Int = UInt.bitWidth &- bits @@ -152,8 +152,8 @@ extension ANKFullWidth { let isLessThanZero = self.isLessThanZero as Bool var next: Self = Self(repeating: isLessThanZero) //=--------------------------------------= - next.withUnsafeMutableWordsPointer { NEXT in - self.withUnsafeWordsPointer { SELF in + next.withUnsafeMutableWords { NEXT in + self.withUnsafeWords { SELF in let a: Int = bits let b: Int = UInt.bitWidth &- bits diff --git a/Sources/ANKFullWidthKit/ANKFullWidth+Subtraction+Digit.swift b/Sources/ANKFullWidthKit/ANKFullWidth+Subtraction+Digit.swift index 45b5686e..002c1882 100644 --- a/Sources/ANKFullWidthKit/ANKFullWidth+Subtraction+Digit.swift +++ b/Sources/ANKFullWidthKit/ANKFullWidth+Subtraction+Digit.swift @@ -49,7 +49,7 @@ extension ANKFullWidth { let lhsWasLessThanZero: Bool = self.isLessThanZero let rhsWasLessThanZero: Bool = amount.isLessThanZero //=--------------------------------------= - let borrow: Bool = self.withUnsafeMutableWordsPointer { LHS in + let borrow: Bool = self.withUnsafeMutableWords { LHS in var index = LHS.startIndex var borrow: Bool = LHS[index].subtractReportingOverflow(UInt(bitPattern: amount)) LHS.formIndex(after: &index) diff --git a/Sources/ANKFullWidthKit/ANKFullWidth+Text.swift b/Sources/ANKFullWidthKit/ANKFullWidth+Text.swift index 04e936bc..1951b178 100644 --- a/Sources/ANKFullWidthKit/ANKFullWidth+Text.swift +++ b/Sources/ANKFullWidthKit/ANKFullWidth+Text.swift @@ -32,7 +32,7 @@ extension ANKFullWidth { } @inlinable public var debugDescription: String { - self.withUnsafeWordsPointer { SELF in + self.withUnsafeWords { SELF in let signedness = !Self.isSigned ? "U" : "" let size = String(Self.bitWidth) let body = SELF.lazy.map(String.init).joined(separator: ", ") @@ -96,7 +96,7 @@ extension ANKFullWidth where High == High.Magnitude { let utf8 = source.utf8 var magnitude: Magnitude = Self() //=--------------------------------------= - let success = magnitude.withUnsafeMutableWordsPointer { MAGNITUDE in + let success = magnitude.withUnsafeMutableWords { MAGNITUDE in //=----------------------------------= var chunkEndIndex = utf8.endIndex var magnitudeIndex = MAGNITUDE.startIndex @@ -181,7 +181,7 @@ extension ANKFullWidth where High == High.Magnitude { let magnitude_ = value.magnitude.minLastIndexReportingIsZeroOrMinusOne() if magnitude_.isZeroOrMinusOne { return "0" } //=--------------------------------------= - return value.magnitude.withUnsafeWordsPointer { MAGNITUDE in + return value.magnitude.withUnsafeWords { MAGNITUDE in var index = magnitude_.minLastIndex //=----------------------------------= var text = value.sign != .plus ? "-" : "" diff --git a/Sources/ANKFullWidthKit/ANKFullWidth+Words.swift b/Sources/ANKFullWidthKit/ANKFullWidth+Words.swift index 50199bf4..f5e60a68 100644 --- a/Sources/ANKFullWidthKit/ANKFullWidth+Words.swift +++ b/Sources/ANKFullWidthKit/ANKFullWidth+Words.swift @@ -74,7 +74,7 @@ extension ANKFullWidth { /// @inlinable public func minLastIndexReportingIsZeroOrMinusOne() -> (minLastIndex: Int, isZeroOrMinusOne: Bool) { let sign: UInt = UInt(repeating: self.isLessThanZero) - let index: Int? = self.withUnsafeWordsPointer({ SELF in SELF.lastIndex(where:{ word in word != sign }) }) + let index: Int? = self.withUnsafeWords({ SELF in SELF.lastIndex(where:{ word in word != sign }) }) return index.map({( $0, false )}) ?? (0, true) } diff --git a/Tests/ANKFullWidthKitTests/192+Collection.swift b/Tests/ANKFullWidthKitTests/192+Collection.swift index 61ebab4a..d0f14686 100644 --- a/Tests/ANKFullWidthKitTests/192+Collection.swift +++ b/Tests/ANKFullWidthKitTests/192+Collection.swift @@ -75,26 +75,26 @@ final class Int192TestsOnCollection: XCTestCase { // MARK: Tests x Words //=------------------------------------------------------------------------= - func testWithUnsafeWordsPointer() { + func testWithUnsafeWords() { let x0 = T(truncatingIfNeeded: 0) let x1 = T(truncatingIfNeeded: -1) - x0.withUnsafeWordsPointer { WORDS in + x0.withUnsafeWords { WORDS in XCTAssertEqual(WORDS.count, T.count) XCTAssert(WORDS.allSatisfy({ $0 == UInt.min })) } - x1.withUnsafeWordsPointer { WORDS in + x1.withUnsafeWords { WORDS in XCTAssertEqual(WORDS.count, T.count) XCTAssert(WORDS.allSatisfy({ $0 == UInt.max })) } } - func testWithUnsafeMutableWordsPointer() { + func testWithUnsafeMutableWords() { var x0 = T(truncatingIfNeeded: 0) let x1 = T(truncatingIfNeeded: -1) - x0.withUnsafeMutableWordsPointer { WORDS in + x0.withUnsafeMutableWords { WORDS in XCTAssertEqual(WORDS.count, T.count) XCTAssert(WORDS.allSatisfy({ $0 == UInt.min })) WORDS.indices.forEach({ WORDS[$0] = UInt.max }) @@ -102,17 +102,17 @@ final class Int192TestsOnCollection: XCTestCase { }; XCTAssertEqual(x0, x1) } - func testFromUnsafeMutableWordsAllocation() { + func testFromUnsafeMutableWords() { let x0 = T(truncatingIfNeeded: 0) let x1 = T(truncatingIfNeeded: -1) - let y0 = T.fromUnsafeMutableWordsAllocation { WORDS in + let y0 = T.fromUnsafeMutableWords { WORDS in XCTAssertEqual(WORDS.count, T.count) WORDS.indices.forEach({ WORDS[$0] = UInt.min }) XCTAssert(WORDS.allSatisfy({ $0 == UInt.min })) }; XCTAssertEqual(x0, y0) - let y1 = T.fromUnsafeMutableWordsAllocation { WORDS in + let y1 = T.fromUnsafeMutableWords { WORDS in XCTAssertEqual(WORDS.count, T.count) WORDS.indices.forEach({ WORDS[$0] = UInt.max }) XCTAssert(WORDS.allSatisfy({ $0 == UInt.max })) @@ -180,26 +180,26 @@ final class UInt192TestsOnCollection: XCTestCase { // MARK: Tests x Words //=------------------------------------------------------------------------= - func testWithUnsafeWordsPointer() { + func testWithUnsafeWords() { let x0 = T(truncatingIfNeeded: 0) let x1 = T(truncatingIfNeeded: -1) - x0.withUnsafeWordsPointer { WORDS in + x0.withUnsafeWords { WORDS in XCTAssertEqual(WORDS.count, T.count) XCTAssert(WORDS.allSatisfy({ $0 == UInt.min })) } - x1.withUnsafeWordsPointer { WORDS in + x1.withUnsafeWords { WORDS in XCTAssertEqual(WORDS.count, T.count) XCTAssert(WORDS.allSatisfy({ $0 == UInt.max })) } } - func testWithUnsafeMutableWordsPointer() { + func testWithUnsafeMutableWords() { var x0 = T(truncatingIfNeeded: 0) let x1 = T(truncatingIfNeeded: -1) - x0.withUnsafeMutableWordsPointer { WORDS in + x0.withUnsafeMutableWords { WORDS in XCTAssertEqual(WORDS.count, T.count) XCTAssert(WORDS.allSatisfy({ $0 == UInt.min })) WORDS.indices.forEach({ WORDS[$0] = UInt.max }) @@ -207,17 +207,17 @@ final class UInt192TestsOnCollection: XCTestCase { }; XCTAssertEqual(x0, x1) } - func testFromUnsafeMutableWordsAllocation() { + func testFromUnsafeMutableWords() { let x0 = T(truncatingIfNeeded: 0) let x1 = T(truncatingIfNeeded: -1) - let y0 = T.fromUnsafeMutableWordsAllocation { WORDS in + let y0 = T.fromUnsafeMutableWords { WORDS in XCTAssertEqual(WORDS.count, T.count) WORDS.indices.forEach({ WORDS[$0] = UInt.min }) XCTAssert(WORDS.allSatisfy({ $0 == UInt.min })) }; XCTAssertEqual(x0, y0) - let y1 = T.fromUnsafeMutableWordsAllocation { WORDS in + let y1 = T.fromUnsafeMutableWords { WORDS in XCTAssertEqual(WORDS.count, T.count) WORDS.indices.forEach({ WORDS[$0] = UInt.max }) XCTAssert(WORDS.allSatisfy({ $0 == UInt.max })) diff --git a/Tests/ANKFullWidthKitTests/256+Collection.swift b/Tests/ANKFullWidthKitTests/256+Collection.swift index ed9ff7e1..45e64af7 100644 --- a/Tests/ANKFullWidthKitTests/256+Collection.swift +++ b/Tests/ANKFullWidthKitTests/256+Collection.swift @@ -75,26 +75,26 @@ final class Int256TestsOnCollection: XCTestCase { // MARK: Tests x Words //=------------------------------------------------------------------------= - func testWithUnsafeWordsPointer() { + func testWithUnsafeWords() { let x0 = T(truncatingIfNeeded: 0) let x1 = T(truncatingIfNeeded: -1) - x0.withUnsafeWordsPointer { WORDS in + x0.withUnsafeWords { WORDS in XCTAssertEqual(WORDS.count, T.count) XCTAssert(WORDS.allSatisfy({ $0 == UInt.min })) } - x1.withUnsafeWordsPointer { WORDS in + x1.withUnsafeWords { WORDS in XCTAssertEqual(WORDS.count, T.count) XCTAssert(WORDS.allSatisfy({ $0 == UInt.max })) } } - func testWithUnsafeMutableWordsPointer() { + func testWithUnsafeMutableWords() { var x0 = T(truncatingIfNeeded: 0) let x1 = T(truncatingIfNeeded: -1) - x0.withUnsafeMutableWordsPointer { WORDS in + x0.withUnsafeMutableWords { WORDS in XCTAssertEqual(WORDS.count, T.count) XCTAssert(WORDS.allSatisfy({ $0 == UInt.min })) WORDS.indices.forEach({ WORDS[$0] = UInt.max }) @@ -102,17 +102,17 @@ final class Int256TestsOnCollection: XCTestCase { }; XCTAssertEqual(x0, x1) } - func testFromUnsafeMutableWordsAllocation() { + func testFromUnsafeMutableWords() { let x0 = T(truncatingIfNeeded: 0) let x1 = T(truncatingIfNeeded: -1) - let y0 = T.fromUnsafeMutableWordsAllocation { WORDS in + let y0 = T.fromUnsafeMutableWords { WORDS in XCTAssertEqual(WORDS.count, T.count) WORDS.indices.forEach({ WORDS[$0] = UInt.min }) XCTAssert(WORDS.allSatisfy({ $0 == UInt.min })) }; XCTAssertEqual(x0, y0) - let y1 = T.fromUnsafeMutableWordsAllocation { WORDS in + let y1 = T.fromUnsafeMutableWords { WORDS in XCTAssertEqual(WORDS.count, T.count) WORDS.indices.forEach({ WORDS[$0] = UInt.max }) XCTAssert(WORDS.allSatisfy({ $0 == UInt.max })) @@ -180,26 +180,26 @@ final class UInt256TestsOnCollection: XCTestCase { // MARK: Tests x Words //=------------------------------------------------------------------------= - func testWithUnsafeWordsPointer() { + func testWithUnsafeWords() { let x0 = T(truncatingIfNeeded: 0) let x1 = T(truncatingIfNeeded: -1) - x0.withUnsafeWordsPointer { WORDS in + x0.withUnsafeWords { WORDS in XCTAssertEqual(WORDS.count, T.count) XCTAssert(WORDS.allSatisfy({ $0 == UInt.min })) } - x1.withUnsafeWordsPointer { WORDS in + x1.withUnsafeWords { WORDS in XCTAssertEqual(WORDS.count, T.count) XCTAssert(WORDS.allSatisfy({ $0 == UInt.max })) } } - func testWithUnsafeMutableWordsPointer() { + func testWithUnsafeMutableWords() { var x0 = T(truncatingIfNeeded: 0) let x1 = T(truncatingIfNeeded: -1) - x0.withUnsafeMutableWordsPointer { WORDS in + x0.withUnsafeMutableWords { WORDS in XCTAssertEqual(WORDS.count, T.count) XCTAssert(WORDS.allSatisfy({ $0 == UInt.min })) WORDS.indices.forEach({ WORDS[$0] = UInt.max }) @@ -207,17 +207,17 @@ final class UInt256TestsOnCollection: XCTestCase { }; XCTAssertEqual(x0, x1) } - func testFromUnsafeMutableWordsAllocation() { + func testFromUnsafeMutableWords() { let x0 = T(truncatingIfNeeded: 0) let x1 = T(truncatingIfNeeded: -1) - let y0 = T.fromUnsafeMutableWordsAllocation { WORDS in + let y0 = T.fromUnsafeMutableWords { WORDS in XCTAssertEqual(WORDS.count, T.count) WORDS.indices.forEach({ WORDS[$0] = UInt.min }) XCTAssert(WORDS.allSatisfy({ $0 == UInt.min })) }; XCTAssertEqual(x0, y0) - let y1 = T.fromUnsafeMutableWordsAllocation { WORDS in + let y1 = T.fromUnsafeMutableWords { WORDS in XCTAssertEqual(WORDS.count, T.count) WORDS.indices.forEach({ WORDS[$0] = UInt.max }) XCTAssert(WORDS.allSatisfy({ $0 == UInt.max }))