package decompress

  1. Overview
  2. Docs
module Safe : sig ... end
module Seq : sig ... end
module Hunk : sig ... end
val repeat : char -> int64
type error =
  1. | Invalid_level of int
  2. | Invalid_wbits of int
val pp_error : Format.formatter -> error -> unit
exception Match of int * int
exception Literal of char
exception Break
type 'i t = {
  1. i_off : int;
  2. i_pos : int;
  3. i_len : int;
  4. level : int;
  5. on : Hunk.t -> unit;
  6. state : 'i state;
}
and 'i state =
  1. | Deflate of int
  2. | Deffast of int
  3. | Choose of int
  4. | Exception of error
and 'i res =
  1. | Cont of 'i t
  2. | Wait of 'i t * Hunk.t Seq.t
  3. | Error of 'i t * error
    (*

    XXX: we don't have an Ok result because this algorithm does not decide if you need to stop the compression or not - this is decided by the user. It's illogic to force a `End state with this algorithm.

    *)
val pp_state : Format.formatter -> 'a state -> unit
val pp : Format.formatter -> 'a t -> unit
val await : 'a t -> Hunk.t Seq.t -> 'a res
val error : 'a t -> error -> 'b res
val _max_distance : int
val _max_length : int
val _size_of_int64 : int
val _idx_boundary : int
type key = Int32.t option
val key : ([< `Read | `Write Read ], 'a) Safe.t -> int -> int -> key
module T : sig ... end
val longuest_substring : ([< `Read | `Write Read ], 'a) Safe.t -> int -> int -> int -> int option
val deflate : ?max_fardistance:int -> ([< `Read | `Write Read ], 'a) Safe.t -> 'b t -> Hunk.t Seq.t
val _hlog : int array
val deffast : 'a. ?accel:int -> ?max_fardistance:int -> (Safe.read, 'a) Safe.t -> 'a t -> Hunk.t Seq.t
val eval : (Safe.read, 'a) Safe.t -> 'b t -> [> `Await of 'c t * Hunk.t Seq.t | `Error of 'd t * error ]
val refill : int -> int -> 'a t -> 'b t
val used_in : 'a t -> int
val default : ?level:int -> ?on:(Hunk.t -> unit) -> int -> 'a t
OCaml

Innovation. Community. Security.