Compression

std.compress groups compression formats under explicit format modules. The current public modules are std.compress.deflate and std.compress.gzip.

std.compress.deflate handles raw DEFLATE and zlib-wrapped DEFLATE. std.compress.gzip handles gzip-wrapped DEFLATE. std.zlib and std.compression.* are not public 0.0.0-dev modules.

Importing std.compress, std.compress.deflate, or std.compress.gzip automatically links the platform zlib library in normal compiler link mode.

import std.compress.deflate;

fn main() {
    let compressed = try deflate.compress("hello");
    let plain = try deflate.decompress(compressed.bytes(), 32);

    let view = plain.bytes();
    assert view.length == 5;
    assert view[0] == 104 as u8;
    assert view[4] == 111 as u8;
}

By default, deflate.compress and deflate.decompress use zlib framing. Pass deflate.Format.Raw for raw DEFLATE streams.

import std.compress.deflate;

fn main() {
    let raw = try deflate.compress("payload",
                                   deflate.best_speed,
                                   deflate.Format.Raw);
    let plain = try deflate.decompress(raw.bytes(),
                                       64,
                                       deflate.Format.Raw);

    assert plain.len() == 7;
}

deflate.Format has Raw and Zlib variants. Compression levels are no_compression, best_speed, best_compression, and default_compression.

Use std.compress.gzip for gzip-wrapped data.

import std.compress.gzip;

fn main() {
    let packed = try gzip.compress("hello gzip", gzip.best_speed);
    let plain = try gzip.decompress(packed.bytes(), 64);

    assert plain.len() == 10;
}

Use compress_into and decompress_into when the destination storage is owned by the caller. These functions return the number of bytes written.

import std.compress.deflate;
import std.mem;

fn main() {
    let packed = [0 as u8, 0 as u8, 0 as u8, 0 as u8,
                  0 as u8, 0 as u8, 0 as u8, 0 as u8,
                  0 as u8, 0 as u8, 0 as u8, 0 as u8,
                  0 as u8, 0 as u8, 0 as u8, 0 as u8];
    let plain = [0 as u8, 0 as u8];

    let packed_len = try deflate.compress_into(
        "ok",
        mem.slice_of<u8>(packed.ptr, packed.length),
        deflate.best_speed,
        deflate.Format.Zlib);

    let plain_len = try deflate.decompress_into(
        mem.slice_of<u8>(packed.ptr, packed_len),
        mem.slice_of<u8>(plain.ptr, plain.length));

    assert plain_len == 2;
    assert plain[0] == 111 as u8;
    assert plain[1] == 107 as u8;
}

Gzip exposes the same caller-owned buffer shape without a format argument:

let n = try gzip.compress_into(source, dest, gzip.best_speed);
let m = try gzip.decompress_into(source, dest);

The allocating helpers return io.MemoryStream throws(CompressError | AllocError | io.IOError). Decompression requires a maximum output byte count. Public inputs use bytes.Bytes, so callers can pass string literals, String, existing byte views, or [u8] slices directly.

Module	Function	Purpose
deflate	compress(source)	Compress with default level and zlib framing.
deflate	compress(source, level)	Compress with explicit level and zlib framing.
deflate	compress(source, level, format)	Compress with explicit level and Raw or Zlib framing.
deflate	compress(source, level, allocator)	Compress with custom storage and zlib framing.
deflate	compress(source, level, format, allocator)	Compress with explicit format and storage.
deflate	decompress(source, max_output)	Decompress zlib-framed data into a new MemoryStream.
deflate	decompress(source, max_output, format)	Decompress raw or zlib-framed data.
deflate	decompress(source, max_output, allocator)	Decompress with custom storage.
deflate	decompress(source, max_output, format, allocator)	Decompress with explicit format and storage.
deflate	compress_into(source, dest)	Compress into caller-provided storage.
deflate	compress_into(source, dest, level)	Compress with explicit level.
deflate	compress_into(source, dest, level, format)	Compress with explicit level and format.
deflate	decompress_into(source, dest)	Decompress zlib-framed data into caller storage.
deflate	decompress_into(source, dest, format)	Decompress raw or zlib-framed data into caller storage.
deflate	compress_bound(source_len)	Return zlib's upper bound for compressed output size.
gzip	compress(source)	Compress with default gzip settings.
gzip	compress(source, level)	Compress gzip data with explicit level.
gzip	compress(source, level, allocator)	Compress gzip data with custom storage.
gzip	decompress(source, max_output)	Decompress gzip data into a new MemoryStream.
gzip	decompress(source, max_output, allocator)	Decompress gzip data with custom storage.
gzip	compress_into(source, dest)	Compress gzip data into caller storage.
gzip	compress_into(source, dest, level)	Compress gzip data with explicit level.
gzip	decompress_into(source, dest)	Decompress gzip data into caller storage.
gzip	compress_bound(source_len)	Return an upper bound for gzip output size.

CRC-32 stays under std.hash.crc32. Compression modules do not expose checksum helpers.

Both modules export CompressError, with Stream, Data, Memory, Buffer, Version, NeedDict, and Error variants.