prune unnecessarily public API, drop some low-value abstractions

Sources/LZ77/Deflator/LZ77.DeflatorBuffers.swift

@@ -1,6 +1,6 @@
 extension LZ77
 {
-    @frozen public
+    @frozen @usableFromInline
     struct DeflatorBuffers<Format> where Format:LZ77.FormatType
     {
         var stream:Stream

Sources/LZ77/Deflator/LZ77.DeflatorTables.swift

@@ -33,11 +33,11 @@ extension LZ77.DeflatorTables
             runliteral.codewords(initializing: $0,       count: 288)
             {
                 $0 > 256 ?
-                .init(LZ77.Composites[run: .init(truncatingIfNeeded: $0)].extra) : 0
+                UInt8.init(LZ77.Composites[run: .init(truncatingIfNeeded: $0)].extra) : 0
             }
             distance.codewords(  initializing: $0 + 288, count:  32)
             {
-                .init(LZ77.Composites[distance: $0].extra)
+                UInt8.init(LZ77.Composites[distance: $0].extra)
             }
             meta?.codewords(     initializing: $0 + 320, count:  19)
             {

Sources/LZ77/Gzip/Gzip.Format.Integral (ext).swift → Sources/LZ77/Gzip/Gzip.Format.Integral.swift

@@ -2,7 +2,7 @@ import CRC
 
 extension Gzip.Format
 {
-    @frozen public
+    @frozen @usableFromInline
     struct Integral
     {
         @usableFromInline
@@ -20,10 +20,10 @@ extension Gzip.Format
 }
 extension Gzip.Format.Integral:LZ77.StreamIntegral
 {
-    @inlinable public
+    @inlinable
     var checksum:UInt32 { self.crc32.checksum }
 
-    @inlinable public mutating
+    @inlinable mutating
     func update(from buffer:UnsafePointer<UInt8>, count:Int)
     {
         self.crc32.update(with: UnsafeBufferPointer.init(start: buffer, count: count))

Sources/LZ77/HuffmanCoding/LZ77.Codeword.swift

@@ -2,29 +2,38 @@ extension LZ77
 {
     struct Codeword
     {
+        private
+        let shape:(length:UInt8, extra:UInt8)
         // bits are stored starting from least-significant bit to most-significant bit
         let bits:UInt16
-        @General.Storage<UInt8>
-        var length:Int
-        @General.Storage<UInt8>
-        var extra:Int
+
+        init(shape:(length:UInt8, extra:UInt8), bits:UInt16)
+        {
+            self.shape = shape
+            self.bits = bits
+        }
     }
 }
 extension LZ77.Codeword
 {
-    init(counter:UInt16, length:Int, extra:Int)
+    init(counter:UInt16, shape:(length:UInt8, extra:UInt8))
     {
         // this branch should be well-predicted
-        if length <= 8
+        if  shape.length <= 8
         {
             let low:UInt16  = LZ77.Reversed[counter]
-            self.init(bits:         low  &>> ( 8 - length), length: length, extra: extra)
+            self.init(shape: shape, bits:         low  &>> ( 8 - shape.length))
         }
         else
         {
             let high:UInt16 = LZ77.Reversed[counter & 0xff] << 8,
                 low:UInt16  = LZ77.Reversed[counter >> 8]
-            self.init(bits: (high | low) &>> (16 - length), length: length, extra: extra)
+            self.init(shape: shape, bits: (high | low) &>> (16 - shape.length))
         }
     }
 }
+extension LZ77.Codeword
+{
+    var length:Int { .init(self.shape.length) }
+    var extra:Int { .init(self.shape.extra) }
+}

Sources/LZ77/General.Heap.swift → Sources/LZ77/HuffmanCoding/LZ77.Heap.swift

@@ -2,7 +2,7 @@
 //  License, v. 2.0. If a copy of the MPL was not distributed with this
 //  file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-extension General
+extension LZ77
 {
     struct Heap<Key, Value> where Key:Comparable
     {
@@ -48,7 +48,7 @@ extension General
         }
     }
 }
-extension General.Heap
+extension LZ77.Heap
 {
     @inline(__always)
     private static
@@ -174,7 +174,7 @@ extension General.Heap
         }
     }
 }
-extension General.Heap:ExpressibleByArrayLiteral
+extension LZ77.Heap:ExpressibleByArrayLiteral
 {
     init(arrayLiteral:(key:Key, value:Value)...)
     {

Sources/LZ77/HuffmanCoding/LZ77.HuffmanTree.swift

@@ -204,23 +204,25 @@ extension LZ77.HuffmanTree where Symbol:BinaryInteger
 extension LZ77.HuffmanTree where Symbol:BinaryInteger
 {
     func codewords(initializing destination:UnsafeMutablePointer<LZ77.Codeword>,
-        count:Int, extra:(Symbol) -> Int)
+        count:Int,
+        extra:(Symbol) -> UInt8)
     {
         // initialize all entries to 0, as symbols with frequency 0 are omitted
         // from self.symbols
-        destination.initialize(repeating: .init(bits: 0, length: 0, extra: 0),
+        destination.initialize(
+            repeating: .init(shape: (length: 0, extra: 0), bits: 0),
             count: count)
 
         var counter:UInt16  = 0
-        for (length, level):(Int, Range<Int>) in zip(1 ... 15, self.levels)
+        for (length, level):(UInt8, Range<Int>) in zip(1 ... 15, self.levels)
         {
             for symbol:Symbol in self.symbols[level]
             {
                 assert(.init(symbol) < count, "symbol out of range")
 
-                destination[.init(symbol)]  =
-                    .init(counter: counter, length: length, extra: extra(symbol))
-                counter                    += 1
+                destination[.init(symbol)] = .init(counter: counter,
+                    shape: (length: length, extra: extra(symbol)))
+                counter += 1
             }
 
             counter <<= 1
@@ -265,7 +267,7 @@ extension LZ77.HuffmanTree where Symbol:BinaryInteger
 
         // reversing (to get canonically sorted array) gets the heapify below
         // to its best-case O(n) time, not that O matters for n = 256
-        var heap:General.Heap<Int, [Int]> = .init(symbols.reversed().map
+        var heap:LZ77.Heap<Int, [Int]> = .init(symbols.reversed().map
         {
             (frequencies[frequencies.startIndex + .init($0)], [1])
         })

Sources/LZ77/Wrappers/LZ77.Format.swift

@@ -13,7 +13,7 @@ extension LZ77
 }
 extension LZ77.Format:LZ77.FormatType
 {
-    public
+    @usableFromInline
     typealias Integral = LZ77.MRC32
 }
 extension LZ77.Format

Sources/LZ77/Wrappers/LZ77.FormatType.swift

@@ -1,13 +1,10 @@
 extension LZ77
 {
-    public
+    @usableFromInline
     typealias FormatType = _LZ77FormatType
 }
-public
+@usableFromInline
 protocol _LZ77FormatType
 {
     associatedtype Integral:LZ77.StreamIntegral
-
-    // func begin(inflating input:inout LZ77.InflatorIn, at bit:inout Int) throws -> Header?
-    // func check(inflating input:inout LZ77.InflatorIn, at bit:inout Int) -> UInt32??
 }

Sources/LZ77/Wrappers/LZ77.MRC32.swift

@@ -1,15 +1,15 @@
 extension LZ77
 {
     /// Modular redundancy check (similar to ``CRC32``)
-    @frozen public
+    @frozen @usableFromInline
     struct MRC32
     {
         @usableFromInline
         var single:UInt32
         @usableFromInline
         var double:UInt32
 
-        @inlinable public
+        @inlinable
         init()
         {
             self.single = 1
@@ -22,7 +22,7 @@ extension LZ77.MRC32:LZ77.StreamIntegral
     // software.intel.com/content/www/us/en/develop/articles/fast-computation-of-adler32-checksums
     // link also says to use simd vectorization, but that just seems to slow
     // things down (probably because llvm is already autovectorizing it)
-    @inlinable public mutating
+    @inlinable mutating
     func update(from start:UnsafePointer<UInt8>, count:Int)
     {
         let (q, r):(Int, Int) = count.quotientAndRemainder(dividingBy: 5552)
@@ -46,6 +46,6 @@ extension LZ77.MRC32:LZ77.StreamIntegral
         self.double %= 65521
     }
 
-    @inlinable public
+    @inlinable
     var checksum:UInt32 { self.double << 16 | self.single }
 }

Sources/LZ77/Wrappers/LZ77.StreamIntegral.swift

@@ -1,9 +1,9 @@
 extension LZ77
 {
-    public
+    @usableFromInline
     typealias StreamIntegral = _LZ77StreamIntegral
 }
-public
+@usableFromInline
 protocol _LZ77StreamIntegral
 {
     init()