README
- ::compareCompressionLevel::compare
- ::equalCompressionLevel::equal
- ::newHeader::new
- ::closeReader::close
- ::multistreamReader::multistream
- ::newReader::new
- ::readReader::read
- ::resetReader::reset
- ::closeWriter::close
- ::flushWriter::flush
- ::newWriter::new
- ::writeWriter::write
V
best_speed
V
err_checksum
V
err_header
V
err_unexpected_eof
V
ioeof

gzip

MoonBit gzip: provide simple gzip and gunzip algorithms.

gzip

gunzip

algorithm

moonbit

Download zip

Author

gmlewis

Version

0.34.15

License

Apache-2.0

Repository

github.com/gmlewis/moonbit-gzip

Last updated

last month

Downloads

#gmlewis/gzip

This is a simplified gzip/gunzip algorithm based on Go's implementation: https://cs.opensource.google/go/go/+/refs/tags/go1.23.0:src/compress/gzip/gzip.go which has the copyright notice:

// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#Status

The code has been updated to support compiler:

$ moon version --all
moon 0.1.20260920 (914d7da 2026-09-20) ~/.moon/bin/moon
moonc v0.10.14+7d59c7ec9 (2026-09-18) ~/.moon/bin/moonc
moonrun 0.1.20260920 (914d7da 2026-09-20) ~/.moon/bin/moonrun

CompressionLevel

source

pub(all) struct CompressionLevel(Int) derive(Compare, Eq)

CompressionLevel::compare

source

fn CompressionLevel::compare(CompressionLevel, CompressionLevel) -> Int

CompressionLevel::equal

source

fn CompressionLevel::equal(CompressionLevel, CompressionLevel) -> Bool

Header

source

pub(all) struct Header {
  comment : String
  extra : Array[Byte]
  mod_time : @moonbitlang/x/time.PlainDateTime
PlainDateTime?
  name : String
  os : Byte
}

The gzip file stores a header giving metadata about the compressed file. That header is exposed as the fields of the [Writer] and [Reader] structs.

Strings must be UTF-8 encoded and may only contain Unicode code points U+0001 through U+00FF, due to limitations of the GZIP file format.

Header::new

source

fn Header::new() -> Header

Reader

source

pub(all) struct Reader {
  header : Header
  // private fields
}

A Reader is an [IOReadCloser] that can be read to retrieve uncompressed data from a gzip-format compressed file.

In general, a gzip file can be a concatenation of gzip files, each with its own header. Reads from the Reader return the concatenation of the uncompressed data of each. Only the first header is recorded in the Reader fields.

Gzip files store a length and checksum of the uncompressed data. The Reader will return an [err_checksum] when [Reader.Read] reaches the end of the uncompressed data if it does not have the expected length or checksum. Clients should treat data returned by [Reader.Read] as tentative until they receive the [ioeof] marking the end of the data.

impl Closer for Reader

fn close(self : Reader) -> @gmlewis/io.IOError
IOError?

source

Close closes the [Reader]. It does not close the underlying [io.Reader]. In order for the GZIP checksum to be verified, the reader must be fully consumed until the [ioeof].

impl ReadCloser for Reader

impl Reader for Reader

Reader::close

source

fn Reader::close(self : Reader) -> @gmlewis/io.IOError
IOError?

Reader::multistream

source

fn Reader::multistream(self : Reader, ok : Bool) -> Unit

Multistream controls whether the reader supports multistream files.

If enabled (the default), the [Reader] expects the input to be a sequence of individually gzipped data streams, each with its own header and trailer, ending at EOF. The effect is that the concatenation of a sequence of gzipped files is treated as equivalent to the gzip of the concatenation of the sequence. This is standard behavior for gzip readers.

Calling Multistream(false) disables this behavior; disabling the behavior can be useful when reading file formats that distinguish individual gzip data streams or mix gzip data streams with other data streams. In this mode, when the [Reader] reaches the end of the data stream, [Reader.Read] returns [ioeof]. The underlying reader must implement [io.ByteReader] in order to be left positioned just after the gzip stream. To start the next stream, call self.Reset(r) followed by self.Multistream(false). If there is no next stream, self.Reset(r) will return [ioeof].

Reader::new

source

fn Reader::new(r : &@gmlewis/flate.Reader
Reader) -> (Reader, @gmlewis/io.IOError
IOError?)

NewReader creates a new [IOReader] reading the given reader.

It is the caller's responsibility to call Close on the [Reader] when done.

The [Reader.Header] fields will be valid in the [Reader] returned.

Reader::read

source

fn Reader::read(self : Reader, p : @gmlewis/io.Slice
Slice[Byte]) -> (Int, @gmlewis/io.IOError
IOError?)

Reader::reset

source

fn Reader::reset(self : Reader, r : &@gmlewis/flate.Reader
Reader) -> @gmlewis/io.IOError
IOError?

Reset discards the [Reader] z's state and makes it equivalent to the result of its original state from [NewReader], but reading from r instead. This permits reusing a [Reader] rather than allocating a new one.

Writer

source

pub(all) struct Writer {
  header : Header
  w : &@gmlewis/io.Writer
Writer
  level : CompressionLevel
  wrote_header : Bool
  closed : Bool
  buf : Array[Byte]
  compressor : &@gmlewis/io.WriteCloser
WriteCloser
  digest : UInt
  size : UInt
  err : @gmlewis/io.IOError
IOError?
}

Writes to a Writer are compressed and written to w.

impl Closer for Writer

fn close(self : Writer) -> @gmlewis/io.IOError
IOError?

source

close closes the [Writer] by flushing any unwritten data to the underlying [io.Writer] and writing the GZIP footer. It does not close the underlying [io.Writer].

impl Writer for Writer

Writer::close

source

fn Writer::close(self : Writer) -> @gmlewis/io.IOError
IOError?

Writer::flush

source

fn Writer::flush(self : Writer) -> @gmlewis/io.IOError
IOError?

flush flushes any pending compressed data to the underlying writer.

It is useful mainly in compressed network protocols, to ensure that a remote reader has enough data to reconstruct a packet. Flush does not return until the data has been written. If the underlying writer returns an error, Flush returns that error.

In the terminology of the zlib library, Flush is equivalent to Z_SYNC_FLUSH.

Writer::new

source

fn Writer::new(w : &@gmlewis/io.Writer
Writer) -> Writer

Writer::new returns a new [IOWriter] using the optional compression level (or default_compression). Writes to the returned writer are compressed and written to w.

It is the caller's responsibility to call Close on the [Writer] when done. Writes may be buffered and not flushed until Close.

Callers that wish to set the fields in Writer.Header must do so before the first call to Write, Flush, or Close.

Writer::write

source

fn Writer::write(self : Writer, p : @gmlewis/io.Slice
Slice[Byte]) -> (Int, @gmlewis/io.IOError
IOError?)

best_speed

source

let best_speed : CompressionLevel

err_checksum

source

let err_checksum : @gmlewis/io.IOError
IOError

err_checksum is returned when reading GZIP data that has an invalid checksum.

err_header

source

let err_header : @gmlewis/io.IOError
IOError

err_header is returned when reading GZIP data that has an invalid header.

err_unexpected_eof

source

let err_unexpected_eof : @gmlewis/io.IOError
IOError

ioeof

source

let ioeof : @gmlewis/io.IOError
IOError

Source Files

Site source Report issue Packages Build queue Skills Statistics

gzip

#gmlewis/gzip

#Status

#CompressionLevel

#CompressionLevel::compare

#CompressionLevel::equal

#Header

#Header::new

#Reader

#Reader::close

#Reader::multistream

#Reader::new

#Reader::read

#Reader::reset

#Writer

#Writer::close

#Writer::flush

#Writer::new

#Writer::write

#best_speed

#err_checksum

#err_header

#err_unexpected_eof

#ioeof

Source Files

CompressionLevel

CompressionLevel::compare

CompressionLevel::equal

Header

Header::new

Reader

Reader::close

Reader::multistream

Reader::new

Reader::read

Reader::reset

Writer

Writer::close

Writer::flush

Writer::new

Writer::write

best_speed

err_checksum

err_header

err_unexpected_eof

ioeof