package decompress

You can search for identifiers within the package.

in-package search v0.2.0

Legend:
Library
Module
Module type
Parameter
Class
Class type

module Safe = Decompress_safe

module Seq = Decompress_seq

module Hunk = Decompress_hunk

module Buffer = Decompress_buffer

val pf : Format.formatter -> ('a, Format.formatter, unit) format -> 'a

val repeat : char -> int64

type error =

val pp_error : Format.formatter -> error -> unit

exception Match of int * int

exception Literal of char

exception Break

type 'i t = {

}

and 'i state =

and 'i res =

val pp_state : Format.formatter -> 'a state -> unit

val pp : Format.formatter -> 'a t -> unit

val await : 'i t -> Hunk.t Seq.t -> 'i res

val error : 'i t -> error -> 'i res

val _max_distance : int

val _max_length : int

val _size_of_int64 : int

val _idx_boundary : int

type key = int32 option

val key : 
  'a Safe.Buffer.t ->
  ([< `Rd | `Wr Rd ], 'a) Safe.t ->
  int ->
  int ->
  key

module T : sig ... end

val longuest_substring : 
  'a Safe.Buffer.t ->
  ([< `Rd | `Wr Rd ], 'a) Safe.t ->
  int ->
  int ->
  int ->
  int option

val deflate : 
  ?max_fardistance:int ->
  ([< `Rd | `Wr Rd ], 'a) Safe.t ->
  'a t ->
  Hunk.t Seq.t

val _hlog : int array

val deffast : 
  'a. ?accel:int ->
  ?max_fardistance:int ->
  (Safe.ro, 'a) Safe.t ->
  'a t ->
  Hunk.t Seq.t

val eval : 
  (Safe.ro, 'a) Safe.t ->
  'a t ->
  [> `Await of 'a t * Hunk.t Seq.t | `Error of 'a t * error ]

val refill : int -> int -> 'a t -> 'a t

val used_in : 'a t -> int

val default : 
  witness:'a Buffer.t ->
  ?level:int ->
  ?on:(Hunk.t -> unit) ->
  int ->
  'a t