decompress 0.8 · OCaml Package

type ('i, 'o) t = {

d : ('i, 'o) RFC1951_inflate.t;
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 =

| Header of ('i, 'o) k
| Inflate
| Adler32 of ('i, 'o) k
| Finish
| Exception of error

and ('i, 'o) res =

| Cont of ('i, 'o) t
| Wait of ('i, 'o) t
| Flush of ('i, 'o) t
| Ok of ('i, 'o) t
| Error of ('i, 'o) t * error

and error = error_z_inflate

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

val pp_state : Format.formatter -> ('a, 'b) state -> unit

val pp : Format.formatter -> ('a, 'b) t -> unit

val error : ('a, 'b) t -> error -> ('c, 'd) res

val ok : ('a, 'b) t -> ('c, 'd) res

val get_byte : 
  ctor:
    ((([< `Read | `Write Read ] as 'a, 'b) Safe.t ->
       'c ->
       ('d, 'e) t ->
       ('f, 'g) res) ->
      ('h, 'i) state) ->
  (int -> ('a, 'b) Safe.t -> 'j -> ('k, 'l) t -> ('f, 'g) res) ->
  ('a, 'b) Safe.t ->
  'm ->
  ('d, 'e) t ->
  ('f, 'g) res

val get_with_holding : 
  ctor:
    ((([< `Read | `Write Read ] as 'a, 'b) Safe.t ->
       'c ->
       ('d, 'e) t ->
       ('d, 'e) res) ->
      ('d, 'e) state) ->
  (int -> ('a, 'b) Safe.t -> 'c -> ('d, 'e) t -> ('d, 'e) res) ->
  ('a, 'b) Safe.t ->
  'f ->
  ('d, 'e) t ->
  ('d, 'e) res

val peek_bits : 
  ctor:
    ((([< `Read | `Write Read ] as 'a, 'b) Safe.t ->
       'c ->
       ('d, 'e) t ->
       ('d, 'e) res) ->
      ('d, 'e) state) ->
  int ->
  (('a, 'b) Safe.t -> 'f -> ('d, 'e) t -> ('d, 'e) res) ->
  ('a, 'b) Safe.t ->
  'g ->
  ('d, 'e) t ->
  ('d, 'e) res

val drop_bits : 
  ctor:
    ((([< `Read | `Write Read ] as 'a, 'b) Safe.t ->
       'c ->
       ('d, 'e) t ->
       ('f, 'g) res) ->
      ('f, 'g) state) ->
  int ->
  (('a, 'b) Safe.t -> 'h -> ('i, 'j) t -> ('f, 'g) res) ->
  ('a, 'b) Safe.t ->
  'k ->
  ('d, 'e) t ->
  ('f, 'g) res

module KHeader : sig ... end

module KCrc : sig ... end

val adler32 : 
  (Safe.read, 'a) Safe.t ->
  (Safe.write, 'b) Safe.t ->
  ('a, 'b) t ->
  ('a, 'b) res

val inflate : 
  (Safe.read, 'a) Safe.t ->
  (Safe.write, 'a) Safe.t ->
  ('b, 'c) t ->
  ('d, 'e) res

val header : 
  (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 : 'a Window.t -> ('b, 'c) t

val refill : 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

val write : ('a, 'b) t -> int

include sig ... end

val to_result : 
  'a B.t ->
  'a B.t ->
  ('a B.t -> int) ->
  ('a B.t -> int -> int) ->
  ('b, 'c) t ->
  (('d, 'e) t, error) result

val bytes : 
  B.Bytes.t ->
  B.Bytes.t ->
  (B.Bytes.t -> 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 ->
  (B.Bigstring.t -> int) ->
  (B.Bigstring.t -> int -> int) ->
  (B.bs, B.bs) t ->
  ((B.bs, B.bs) t, error) result

package decompress