Skip to content
Topaz6.0 · Before release
Download

Search documentation

Specification 6.0 · Not released · Tested product 5.21.3

Use arrow keys to choose a result. Press Enter to open.

Type an API name, diagnostic number, rule, or project topic.

    Library · std.bytes

    Bytes.deflateFixedCompress

    Compresses this byte sequence using fixed DEFLATE coding.

    deflateFixedCompress() -> Result<Bytes, string>
    Module
    std.bytes
    Receiver
    Bytes
    Minimum arity
    0
    Maximum arity
    0

    Declaration and parameters

    Link

    Availability

    Included by default: Pending

    Import std.bytes in language mode 5.21.

    The current compiler selects std/bytes.tpz for this language mode. Availability in other released editions and inclusion in each installed distribution are Pending.

    Source evidence

    Receiver

    Bytes

    Parameter constraints

    Additional contracts are Pending.

    Bytes.deflateCompress returns Ok with one complete raw RFC 1951 DEFLATE stream. It adds no zlib or gzip header or checksum.

    Bytes.deflateFixedCompress returns Ok with one final fixed Huffman block. Empty input is valid and the final unused bits are zero.

    Fixed Huffman compression accepts at most 268435456 input bytes. Larger inputs return Err with a string before producing output.

    Bytes.zlibFixedCompress applies the same fixed Huffman compression and input bound, with an RFC 1950 zlib header and Adler-32 trailer.

    The zlib stream declares a 32768-byte window and no preset dictionary. Its header bytes are 0x78 and 0x01.

    Bytes.deflateDecompress accepts raw streams containing stored, fixed Huffman, and dynamic Huffman blocks. It reconstructs the original bytes in Ok.

    The decoder consumes one complete stream. Malformed or truncated blocks, invalid back-references, and complete trailing bytes return Err with a string.

    Final unused padding bits are not decoded as data. A zlib or gzip wrapper is not a raw DEFLATE stream.

    Bytes.deflateDecompress reverses either raw compressor for every supported input. Bytes.zlibFixedCompress requires a zlib decoder because its wrapper is part of the result.

    Each receiver evaluates once and remains unchanged. The operations perform no I/O and errors expose no partially decoded Bytes.

    Compression does not promise a particular size reduction. Except for the fixed block and wrapper requirements, encoded byte choices may change while preserving the stream format.

    Related rule: Distinguish raw DEFLATE from zlib framing

    Result

    Additional contracts are Pending.

    The declared result type is Result<Bytes, string>.

    Effects

    Pending

    Failures

    Pending

    Result and effects

    Link

    Return one final fixed Huffman DEFLATE block in Ok. Input beyond 268435456 bytes returns Err.

    Resolved contracts

    Link

    Related entries

    Link

    std.bytes

    Distinguish raw DEFLATE from zlib framing

    Link
    Ruletopaz.stdlib.contract.bytes-deflate.rule

    Distinguish raw DEFLATE from zlib framing

    Bytes.deflateCompress returns Ok with one complete raw RFC 1951 DEFLATE stream. It adds no zlib or gzip header or checksum.

    Bytes.deflateFixedCompress returns Ok with one final fixed Huffman block. Empty input is valid and the final unused bits are zero.

    Fixed Huffman compression accepts at most 268435456 input bytes. Larger inputs return Err with a string before producing output.

    Bytes.zlibFixedCompress applies the same fixed Huffman compression and input bound, with an RFC 1950 zlib header and Adler-32 trailer.

    The zlib stream declares a 32768-byte window and no preset dictionary. Its header bytes are 0x78 and 0x01.

    Bytes.deflateDecompress accepts raw streams containing stored, fixed Huffman, and dynamic Huffman blocks. It reconstructs the original bytes in Ok.

    The decoder consumes one complete stream. Malformed or truncated blocks, invalid back-references, and complete trailing bytes return Err with a string.

    Final unused padding bits are not decoded as data. A zlib or gzip wrapper is not a raw DEFLATE stream.

    Bytes.deflateDecompress reverses either raw compressor for every supported input. Bytes.zlibFixedCompress requires a zlib decoder because its wrapper is part of the result.

    Each receiver evaluates once and remains unchanged. The operations perform no I/O and errors expose no partially decoded Bytes.

    Compression does not promise a particular size reduction. Except for the fixed block and wrapper requirements, encoded byte choices may change while preserving the stream format.

    Why

    Raw DEFLATE and zlib are different wire formats. The fixed Huffman operation additionally specifies block coding, so it serves a distinct format requirement rather than another name for a general compressor.

    Examples Recover bytes from a raw streamDecode a valid fixed Huffman streamDecode short nonfinal stored blocksIgnore stored block alignment bitsReject truncated streams and trailing bytes

    Source evidence

    Recover bytes from a raw stream

    Link

    run · running · Verification: not-run

    main.tpzRecover bytes from a raw streamOpen in Playground
    1. import std.io
    2. import std.test
    4. let encoded = test.assertOk("hello".encodeUtf8().deflateCompress())
    5. io.writeLine(test.assertOk(encoded.deflateDecompress()).toHex())
    6. io.writeLine(test.assertOk("".encodeUtf8().deflateFixedCompress()).toHex())
    7. io.writeLine(test.assertOk("".encodeUtf8().zlibFixedCompress()).toHex())
    Expected outputexit 0
    68656c6c6f
0300
7801030000000001
    $ topaz run main.tpz · target product 5.21.3
    Expected result

    Expected result

    Execution completes. Exit code 0.

    No stderr.

    Expected stdout
    1. 68656c6c6f
    2. 0300
    3. 7801030000000001

    This exact example has not been executed.

    Source evidence

    Decode a valid fixed Huffman stream

    Link

    run · running · Verification: not-run

    main.tpzDecode a valid fixed Huffman streamOpen in Playground
    1. import std.bytes { Bytes }
    2. import std.io
    3. import std.test
    5. let encoded = test.assertOk(Bytes.fromHex("cb48cdc9c90700"))
    6. match (encoded.deflateDecompress()) {
    7. case Ok(bytes) => io.writeLine(bytes.toHex())
    8. case Err(_) => io.writeLine("rejected")
    9. }
    Expected outputexit 0
    68656c6c6f
    $ topaz run main.tpz · target product 5.21.3
    Expected result

    Expected result

    Execution completes. Exit code 0.

    No stderr.

    Expected stdout
    1. 68656c6c6f

    This exact example has not been executed.

    Source evidence

    Decode short nonfinal stored blocks

    Link

    run · running · Verification: not-run

    main.tpzDecode short nonfinal stored blocksOpen in Playground
    1. import std.bytes { Bytes }
    2. import std.io
    3. import std.test
    5. let encoded = test.assertOk(Bytes.fromHex("000100feff41010100feff42"))
    6. match (encoded.deflateDecompress()) {
    7. case Ok(bytes) => io.writeLine(bytes.toHex())
    8. case Err(_) => io.writeLine("rejected")
    9. }
    Expected outputexit 0
    4142
    $ topaz run main.tpz · target product 5.21.3
    Expected result

    Expected result

    Execution completes. Exit code 0.

    No stderr.

    Expected stdout
    1. 4142

    This exact example has not been executed.

    Source evidence

    Ignore stored block alignment bits

    Link

    run · running · Verification: not-run

    main.tpzIgnore stored block alignment bitsOpen in Playground
    1. import std.bytes { Bytes }
    2. import std.io
    3. import std.test
    5. let encoded = test.assertOk(Bytes.fromHex("f90100feff41"))
    6. match (encoded.deflateDecompress()) {
    7. case Ok(bytes) => io.writeLine(bytes.toHex())
    8. case Err(_) => io.writeLine("rejected")
    9. }
    Expected outputexit 0
    41
    $ topaz run main.tpz · target product 5.21.3
    Expected result

    Expected result

    Execution completes. Exit code 0.

    No stderr.

    Expected stdout
    1. 41

    This exact example has not been executed.

    Source evidence

    Reject truncated streams and trailing bytes

    Link

    run · running · Verification: not-run

    main.tpzReject truncated streams and trailing bytesOpen in Playground
    1. import std.bytes { Bytes }
    2. import std.io
    3. import std.test
    5. for hex in (["", "010100feff", "010000ffff00", "070000"]) {
    6. match (test.assertOk(Bytes.fromHex(hex)).deflateDecompress()) {
    7. case Err(_) => io.writeLine("invalid DEFLATE")
    8. case Ok(_) => io.writeLine("accepted")
    9. }
    10. }
    Expected outputexit 0
    invalid DEFLATE
invalid DEFLATE
invalid DEFLATE
invalid DEFLATE
    $ topaz run main.tpz · target product 5.21.3
    Expected result

    Expected result

    Execution completes. Exit code 0.

    No stderr.

    Expected stdout
    1. invalid DEFLATE
    2. invalid DEFLATE
    3. invalid DEFLATE
    4. invalid DEFLATE

    This exact example has not been executed.

    Source evidence

    Menu

    Download