Replace transformation methods with init pattern

Use idiomatic Swift inits for type transformations instead of methods.
Transformations should use `init`, not methods like `.asDouble()`.

Changes:
- Remove [UInt8].IEEE754.asDouble(endianness:) method
- Remove [UInt8].IEEE754.asFloat(endianness:) method
- Add Double.init(_ ieee754: [UInt8].IEEE754, endianness:)
- Add Float.init(_ ieee754: [UInt8].IEEE754, endianness:)
- Make IEEE754 namespace struct inits internal (not public)
- Update all tests to use init pattern

API now uses idiomatic Swift transformation pattern:
  let value = Double(bytes.ieee754)           // Namespace wrapper
  let value = Double(bytes: data)             // Direct canonical
  let value = Float(bytes.ieee754, endianness: .big)

Tests: All 12 tests passing

Author: coenttb

Sources/IEEE_754/Double+IEEE_754.swift

@@ -19,7 +19,7 @@ extension Double {
     public struct IEEE754 {
         public let double: Double
 
-        public init(double: Double) {
+        init(double: Double) {
             self.double = double
         }
     }

Sources/IEEE_754/Float+IEEE_754.swift

@@ -19,7 +19,7 @@ extension Float {
     public struct IEEE754 {
         public let float: Float
 
-        public init(float: Float) {
+        init(float: Float) {
             self.float = float
         }
     }
@@ -52,6 +52,28 @@ extension Float {
         }
         self = value
     }
+
+    /// Creates Float from namespace-wrapped IEEE 754 binary32 bytes
+    ///
+    /// Convenience init for transforming namespace-wrapped bytes to Float.
+    /// Delegates to `IEEE_754.Binary32.value(from:endianness:)`.
+    ///
+    /// - Parameters:
+    ///   - ieee754: Namespace-wrapped byte array
+    ///   - endianness: Byte order of input bytes
+    /// - Returns: nil if bytes.count ≠ 4
+    ///
+    /// Example:
+    /// ```swift
+    /// let value = Float(bytes.ieee754)
+    /// let value = Float(bytes.ieee754, endianness: .big)
+    /// ```
+    public init?(_ ieee754: [UInt8].IEEE754, endianness: [UInt8].Endianness = .little) {
+        guard let value = IEEE_754.Binary32.value(from: ieee754.bytes, endianness: endianness) else {
+            return nil
+        }
+        self = value
+    }
 }
 
 // MARK: - Type-level Methods

Sources/IEEE_754/[UInt8]+IEEE_754.swift

@@ -19,7 +19,7 @@ extension [UInt8] {
     public struct IEEE754 {
         public let bytes: [UInt8]
 
-        public init(bytes: [UInt8]) {
+        init(bytes: [UInt8]) {
             self.bytes = bytes
         }
     }
@@ -71,42 +71,6 @@ extension [UInt8].IEEE754 {
     }
 }
 
-// MARK: - Instance Methods (Deserialization)
-
-extension [UInt8].IEEE754 {
-    /// Interprets bytes as IEEE 754 binary64 and returns Double
-    ///
-    /// Convenience that delegates to `IEEE_754.Binary64.value(from:endianness:)`.
-    ///
-    /// - Parameter endianness: Byte order of input bytes
-    /// - Returns: Double value, or nil if bytes.count ≠ 8
-    ///
-    /// Example:
-    /// ```swift
-    /// let value = bytes.ieee754.asDouble()
-    /// let value = bytes.ieee754.asDouble(endianness: .big)
-    /// ```
-    public func asDouble(endianness: [UInt8].Endianness = .little) -> Double? {
-        IEEE_754.Binary64.value(from: bytes, endianness: endianness)
-    }
-
-    /// Interprets bytes as IEEE 754 binary32 and returns Float
-    ///
-    /// Convenience that delegates to `IEEE_754.Binary32.value(from:endianness:)`.
-    ///
-    /// - Parameter endianness: Byte order of input bytes
-    /// - Returns: Float value, or nil if bytes.count ≠ 4
-    ///
-    /// Example:
-    /// ```swift
-    /// let value = bytes.ieee754.asFloat()
-    /// let value = bytes.ieee754.asFloat(endianness: .big)
-    /// ```
-    public func asFloat(endianness: [UInt8].Endianness = .little) -> Float? {
-        IEEE_754.Binary32.value(from: bytes, endianness: endianness)
-    }
-}
-
 // MARK: - Canonical [UInt8] Initializers
 
 extension [UInt8] {

Tests/IEEE_754_Tests/IEEE_754_Tests.swift

@@ -12,7 +12,7 @@ struct Binary64Tests {
     func doubleRoundTrip() {
         let original: Double = 3.14159265358979323846
         let bytes = original.ieee754.bytes()
-        let restored = bytes.ieee754.asDouble()
+        let restored = Double(bytes.ieee754)
 
         #expect(restored == original)
     }
@@ -30,7 +30,7 @@ struct Binary64Tests {
     func doubleBigEndian() {
         let value: Double = 3.14159
         let bytes = value.ieee754.bytes(endianness: .big)
-        let restored = bytes.ieee754.asDouble(endianness: .big)
+        let restored = Double(bytes.ieee754, endianness: .big)
 
         #expect(restored == value)
     }
@@ -48,15 +48,15 @@ struct Binary64Tests {
     func doubleSpecialValues() {
         // Zero
         let zero = (0.0 as Double).ieee754.bytes()
-        #expect(zero.ieee754.asDouble() == 0.0)
+        #expect(Double(bytes: zero) == 0.0)
 
         // Infinity
         let inf = Double.infinity.ieee754.bytes()
-        #expect(inf.ieee754.asDouble() == Double.infinity)
+        #expect(Double(bytes: inf) == Double.infinity)
 
         // NaN
         let nan = Double.nan.ieee754.bytes()
-        #expect(nan.ieee754.asDouble()?.isNaN == true)
+        #expect(Double(bytes: nan)?.isNaN == true)
     }
 }
 
@@ -66,7 +66,7 @@ struct Binary32Tests {
     func floatRoundTrip() {
         let original: Float = 3.14159
         let bytes = original.ieee754.bytes()
-        let restored = bytes.ieee754.asFloat()
+        let restored = Float(bytes.ieee754)
 
         #expect(restored == original)
     }
@@ -84,7 +84,7 @@ struct Binary32Tests {
     func floatBigEndian() {
         let value: Float = 3.14
         let bytes = value.ieee754.bytes(endianness: .big)
-        let restored = bytes.ieee754.asFloat(endianness: .big)
+        let restored = Float(bytes.ieee754, endianness: .big)
 
         #expect(restored == value)
     }
@@ -102,15 +102,15 @@ struct Binary32Tests {
     func floatSpecialValues() {
         // Zero
         let zero = Float(0.0).ieee754.bytes()
-        #expect(zero.ieee754.asFloat() == 0.0)
+        #expect(Float(bytes: zero) == 0.0)
 
         // Infinity
         let inf = Float.infinity.ieee754.bytes()
-        #expect(inf.ieee754.asFloat() == Float.infinity)
+        #expect(Float(bytes: inf) == Float.infinity)
 
         // NaN
         let nan = Float.nan.ieee754.bytes()
-        #expect(nan.ieee754.asFloat()?.isNaN == true)
+        #expect(Float(bytes: nan)?.isNaN == true)
     }
 }