decompress 0.9.0 · OCaml Package

type error = error_z

module F = RFC1951.F

type ('i, 'o) t = {

d : ('i, 'o) RFC1951.t;
z : ('i, 'o) state;

}

and ('i, 'o) k =
  (Safe.ro, 'i) Safe.t ->
  (Safe.wo, 'o) Safe.t ->
  ('i, 'o) t ->
  ('i, 'o) res

and ('i, 'o) state =

| Header of ('i, 'o) k
| Deflate
| 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 meth = RFC1951.meth =

| PARTIAL
| SYNC
| FULL

val pp_error : Stdlib.Format.formatter -> error_z -> unit

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

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

val ok : ('i, 'o) t -> ('i0, 'o0) res

val error : ('i, 'o) t -> error -> ('i0, 'o0) res

val put_byte : 
  ctor:
    (('a -> ([< `Rd | `Wr Wr ] 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 -> ([< `Rd | `Wr Wr ] as 'b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res) ->
      ('d, 'c) state) ->
  int ->
  ('a -> ('b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res) ->
  'e ->
  ('b, 'c) Safe.t ->
  ('d, 'c) t ->
  ('d, 'c) res

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

val put_short_msb : 
  ctor:
    (('a -> ([< `Rd | `Wr Wr ] as 'b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res) ->
      ('d, 'c) state) ->
  int ->
  ('a -> ('b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res) ->
  'e ->
  ('b, 'c) Safe.t ->
  ('d, 'c) t ->
  ('d, 'c) res

module KHeader : sig ... end

module KAdler32 : sig ... end

val adler32 : 
  (Safe.ro, 'a) Safe.t ->
  (Safe.wo, 'b) Safe.t ->
  ('a, 'b) t ->
  ('a, 'b) res

val deflate : 
  (Lz77.Safe.ro, 'a) Lz77.Safe.t ->
  (Safe.wo, 'a) Safe.t ->
  ('b, 'c) t ->
  ('d, 'e) res

val header : 
  int ->
  (Safe.ro, 'a) Safe.t ->
  (Safe.wo, 'b) Safe.t ->
  ('a, 'b) t ->
  ('a, 'b) res

val eval : 
  'a ->
  'b ->
  ('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 : witness:'a Safe.Buffer.t -> ?wbits:int -> int -> ('b, 'c) t

val get_frequencies : ('a, 'b) t -> RFC1951.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.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 ->
  ?meth:(meth * int) ->
  ('c -> int option -> int) ->
  ('d -> int -> int) ->
  ('e, 'f) t ->
  (('g, 'h) t, error) Stdlib.result

val bytes : 
  'a ->
  'b ->
  ?meth:(meth * int) ->
  ('c -> int option -> int) ->
  ('c -> int -> int) ->
  ('d, 'e) t ->
  (('f, 'g) t, error) Stdlib.result

val bigstring : 
  'a ->
  'b ->
  ?meth:(meth * int) ->
  ('c -> int option -> int) ->
  ('c -> int -> int) ->
  ('d, 'e) t ->
  (('f, 'g) t, error) Stdlib.result

package decompress