             return try Swift.withUnsafeMutableBytes(of: &bytes) { (rawBuffer) throws -> Result in
                 return try apply(UnsafeMutableRawBufferPointer(start: rawBuffer.baseAddress, count: count))
             }
+        }
+
+        @inlinable // This is @inlinable as tribially computable.
+        mutating func append(byte: UInt8) {
+            let count = self.count
+            assert(count + 1 <= MemoryLayout<Buffer>.size)
+            Swift.withUnsafeMutableBytes(of: &bytes) { $0[count] = byte }
+            self.length += 1
         }
 
         @inlinable // This is @inlinable as trivially computable.

                // Copy the contents of buffer...
                _representation = _Representation(UnsafeRawBufferPointer(start: base, count: endIndex))

                // ... and append the rest byte-wise.
                while let element = iter.next() {
                    Swift.withUnsafeBytes(of: element) {
                        _representation.append(contentsOf: $0)
                    }
                }
            }

            // Copy the contents of the buffer...
            _representation.append(contentsOf: UnsafeRawBufferPointer(start: base, count: endIndex))

            // ... and append the rest byte-wise, buffering through an InlineData.
            var buffer = InlineData()
            while let element = iter.next() {
                if buffer.count < buffer.capacity {
                    buffer.append(byte: element)
                } else {
                    buffer.withUnsafeBytes {_representation.append(contentsOf: $0)}
                    buffer.count = 0
                }
            }
        }
