package decompress

  1. Overview
  2. Docs
type error = error_z_deflate
type ('i, 'o) t = {
  1. d : ('i, 'o) RFC1951_deflate.t;
  2. z : ('i, 'o) state;
}
and ('i, 'o) k = (Safe.read, 'i) Safe.t -> (Safe.write, 'o) Safe.t -> ('i, 'o) t -> ('i, 'o) res
and ('i, 'o) state =
  1. | Header of ('i, 'o) k
  2. | Deflate
  3. | Adler32 of ('i, 'o) k
  4. | Finish
  5. | Exception of error
and ('i, 'o) res =
  1. | Cont of ('i, 'o) t
  2. | Wait of ('i, 'o) t
  3. | Flush of ('i, 'o) t
  4. | Ok of ('i, 'o) t
  5. | Error of ('i, 'o) t * error
and meth = RFC1951_deflate.meth =
  1. | PARTIAL
  2. | SYNC
  3. | FULL
val pp_error : Format.formatter -> error_z_deflate -> unit
val pp_state : Format.formatter -> ('a, 'b) state -> unit
val pp : Format.formatter -> ('a, 'b) t -> unit
val ok : ('a, 'b) t -> ('c, 'd) res
val error : ('a, 'b) t -> error -> ('c, 'd) res
val put_byte : ctor: (('a -> ([< `Read | `Write Write ] as 'b, 'c) Safe.t -> ('d, 'e) t -> ('f, 'g) res) -> ('h, 'i) state) -> int -> ('j -> ('b, 'c) Safe.t -> ('k, 'l) t -> ('f, 'g) res) -> 'm -> ('b, 'c) Safe.t -> ('d, 'e) t -> ('f, 'g) res
val put_short_lsb : ctor: (('a -> ([< `Read | `Write Write ] as 'b, 'c) Safe.t -> ('d, 'e) t -> ('d, 'e) res) -> ('d, 'e) state) -> int -> ('a -> ('b, 'c) Safe.t -> ('d, 'e) t -> ('d, 'e) res) -> 'f -> ('b, 'c) Safe.t -> ('d, 'e) t -> ('d, 'e) res
val align : ctor: (('a -> ([< `Read | `Write Write ] as 'b, 'c) Safe.t -> ('d, 'e) t -> ('f, 'g) res) -> ('f, 'g) state) -> ('h -> ('i, 'j) Safe.t -> ('k, 'l) t -> ('f, 'g) res) -> 'm -> ('i, 'j) Safe.t -> ('d, 'e) t -> ('f, 'g) res
val put_short_msb : ctor: (('a -> ([< `Read | `Write Write ] as 'b, 'c) Safe.t -> ('d, 'e) t -> ('d, 'e) res) -> ('d, 'e) state) -> int -> ('a -> ('b, 'c) Safe.t -> ('d, 'e) t -> ('d, 'e) res) -> 'f -> ('b, 'c) Safe.t -> ('d, 'e) t -> ('d, 'e) res
module KHeader : sig ... end
module KAdler32 : sig ... end
val adler32 : (Safe.read, 'a) Safe.t -> (Safe.write, 'b) Safe.t -> ('a, 'b) t -> ('a, 'b) res
val deflate : (L.Safe.read, 'a) L.Safe.t -> (Safe.write, 'a) Safe.t -> ('b, 'c) t -> ('d, 'e) res
val header : int -> (Safe.read, 'a) Safe.t -> (Safe.write, 'b) Safe.t -> ('a, 'b) t -> ('a, 'b) res
val eval : 'a Decompress_impl__.Decompress_b.t -> 'b Decompress_impl__.Decompress_b.t -> ('c, 'd) t -> [> `Await of ('e, 'f) t | `End of ('g, 'h) t | `Error of ('i, 'j) t * error | `Flush of ('k, 'l) t ]
val default : proof:'a B.t -> ?wbits:int -> int -> ('b, 'c) t
val get_frequencies : ('a, 'b) t -> RFC1951_deflate.F.t
val set_frequencies : ?paranoid:bool -> (int array * int array) -> ('a, 'b) t -> ('c, 'd) t
val finish : ('a, 'b) t -> ('c, 'd) t
val no_flush : int -> int -> ('a, 'b) t -> ('c, 'd) t
val partial_flush : int -> int -> ('a, 'b) t -> ('c, 'd) t
val sync_flush : int -> int -> ('a, 'b) t -> ('c, 'd) t
val full_flush : int -> int -> ('a, 'b) t -> ('c, 'd) t
val flush_of_meth : RFC1951_deflate.meth -> int -> int -> ('a, 'b) t -> ('c, 'd) t
val flush : int -> int -> ('a, 'b) t -> ('c, 'd) t
val used_in : ('a, 'b) t -> int
val used_out : ('a, 'b) t -> int
include sig ... end
val to_result : 'a B.t -> 'a B.t -> ?meth:(meth * int) -> ('a B.t -> int option -> int) -> ('a B.t -> int -> int) -> ('b, 'c) t -> (('d, 'e) t, error) result
val bytes : B.Bytes.t -> B.Bytes.t -> ?meth:(meth * int) -> (B.Bytes.t -> int option -> int) -> (B.Bytes.t -> int -> int) -> (B.st, B.st) t -> ((B.st, B.st) t, error) result
val bigstring : B.Bigstring.t -> B.Bigstring.t -> ?meth:(meth * int) -> (B.Bigstring.t -> int option -> int) -> (B.Bigstring.t -> int -> int) -> (B.bs, B.bs) t -> ((B.bs, B.bs) t, error) result
OCaml

Innovation. Community. Security.