package kaputt

  1. Overview
  2. Docs
type !'a lazy_list =
  1. | Nil
  2. | Cons of 'a * 'a lazy_list lazy_t
type !'a t = (unit -> 'a lazy_list) * ('a -> string)
val iter_list : ('a -> unit) -> 'a lazy_list -> unit
val iter : ('a -> unit) -> 'a t -> unit
val empty : 'a t
val unit : unit t
val bool : bool t
val int : int -> int -> int t
val int32 : int32 -> int32 -> int32 t
val int64 : int64 -> int64 -> int64 t
val nativeint : nativeint -> nativeint -> nativeint t
val make_char : char -> char -> char t
val char : char t
val string : char t -> int -> string t
val float : float -> float -> int -> float t
val complex : float t -> float t -> Complex.t t
val array : 'a t -> int -> 'a array t
val list : 'a t -> int -> 'a list t
val option : 'a t -> 'a option t
val ref : 'a t -> 'a Pervasives.ref t
val buffer : char t -> int -> Buffer.t t
val queue : 'a t -> int -> 'a Queue.t t
val stack : 'a t -> int -> 'a Stack.t t
val weak : 'a option t -> int -> 'a Weak.t t
val file_chars : string -> char t
val file_bytes : string -> int t
val file_lines : string -> string t
val file_values : string -> ('a -> string) -> 'a t
val lift : 'a -> string -> 'a t
val lift_list : 'a list -> ('a -> string) -> 'a t
val lift_array : 'a array -> ('a -> string) -> 'a t
val lift_string : string -> char t
val filter : ('a -> bool) -> 'a t -> 'a t
val transform : ('a -> 'a) -> 'a t -> 'a t
val sequence : 'a t list -> 'a t
val for_each : int -> int -> (int -> 'a t) -> 'a t
val map1 : ('a -> 'b) -> ('b -> string) -> 'a t -> 'b t
val map2 : ('a -> 'b -> 'c) -> ('c -> string) -> ('a t * 'b t) -> 'c t
val map3 : ('a -> 'b -> 'c -> 'd) -> ('d -> string) -> ('a t * 'b t * 'c t) -> 'd t
val map4 : ('a -> 'b -> 'c -> 'd -> 'e) -> ('e -> string) -> ('a t * 'b t * 'c t * 'd t) -> 'e t
val map5 : ('a -> 'b -> 'c -> 'd -> 'e -> 'f) -> ('f -> string) -> ('a t * 'b t * 'c t * 'd t * 'e t) -> 'f t
val zip1 : 'a t -> 'a t
val zip2 : 'a t -> 'b t -> ('a * 'b) t
val zip3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
val zip4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t
val zip5 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> ('a * 'b * 'c * 'd * 'e) t
val create_int_functions : ?inf_eq:('a -> 'a -> bool) -> ('a -> 'a) -> ('a -> string) -> 'a -> 'a -> 'a t
module State : sig ... end
val create_state_based : (unit -> 'a t array) -> ('a State.state -> 'b) -> 'c -> (unit -> 'b lazy_list) * 'c