package osnap

You can search for identifiers within the package.

in-package search v0.2.0

package osnap

osnap
- Osnap
  - Runner
  - Spec
    
    Gen
  - Test

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of QCheck.Gen

type !'a t = Stdlib.Random.State.t -> 'a

type !'a sized = int -> Stdlib.Random.State.t -> 'a

val return : 'a -> 'a t

val pure : 'a -> 'a t

val (>>=) : 'a t -> ('a -> 'b t) -> 'b t

val (<*>) : ('a -> 'b) t -> 'a t -> 'b t

val map : ('a -> 'b) -> 'a t -> 'b t

val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t

val map3 : ('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t

val map_keep_input : ('a -> 'b) -> 'a t -> ('a * 'b) t

val (>|=) : 'a t -> ('a -> 'b) -> 'b t

val (<$>) : ('a -> 'b) -> 'a t -> 'b t

val oneof : 'a t list -> 'a t

val oneofl : 'a list -> 'a t

val oneofa : 'a array -> 'a t

val frequency : (int * 'a t) list -> 'a t

val frequencyl : (int * 'a) list -> 'a t

val frequencya : (int * 'a) array -> 'a t

val shuffle_a : 'a array -> unit t

val shuffle_l : 'a list -> 'a list t

val shuffle_w_l : (int * 'a) list -> 'a list t

val range_subset : size:int -> int -> int -> int array t

val array_subset : int -> 'a array -> 'a array t

val unit : unit t

val bool : bool t

val float : float t

val pfloat : float t

val nfloat : float t

val float_bound_inclusive : float -> float t

val float_bound_exclusive : float -> float t

val float_range : float -> float -> float t

val (--.) : float -> float -> float t

val nat : int t

val big_nat : int t

val neg_int : int t

val pint : int t

val int : int t

val small_nat : int t

val small_int : int t

val small_signed_int : int t

val int_bound : int -> int t

val int_range : int -> int -> int t

val graft_corners : 'a t -> 'a list -> unit -> 'a t

val int_pos_corners : int list

val int_corners : int list

val (--) : int -> int -> int t

val ui32 : int32 t

val ui64 : int64 t

val list : 'a t -> 'a list t

val list_size : int t -> 'a t -> 'a list t

val list_repeat : int -> 'a t -> 'a list t

val array : 'a t -> 'a array t

val array_size : int t -> 'a t -> 'a array t

val array_repeat : int -> 'a t -> 'a array t

val option : ?ratio:float -> 'a t -> 'a option t

val opt : ?ratio:float -> 'a t -> 'a option t

val pair : 'a t -> 'b t -> ('a * 'b) t

val triple : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t

val quad : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t

val tup2 : 'a t -> 'b t -> ('a * 'b) t

val tup3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t

val tup4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t

val tup5 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> ('a * 'b * 'c * 'd * 'e) t

val tup6 : 
  'a t ->
  'b t ->
  'c t ->
  'd t ->
  'e t ->
  'f t ->
  ('a * 'b * 'c * 'd * 'e * 'f) t

val tup7 : 
  'a t ->
  'b t ->
  'c t ->
  'd t ->
  'e t ->
  'f t ->
  'g t ->
  ('a * 'b * 'c * 'd * 'e * 'f * 'g) t

val tup8 : 
  'a t ->
  'b t ->
  'c t ->
  'd t ->
  'e t ->
  'f t ->
  'g t ->
  'h t ->
  ('a * 'b * 'c * 'd * 'e * 'f * 'g * 'h) t

val tup9 : 
  'a t ->
  'b t ->
  'c t ->
  'd t ->
  'e t ->
  'f t ->
  'g t ->
  'h t ->
  'i t ->
  ('a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i) t

val char : char t

val printable : char t

val numeral : char t

val char_range : char -> char -> char t

val bytes_size : ?gen:char t -> int t -> bytes t

val bytes : ?gen:char t -> bytes t

val bytes_of : char t -> bytes t

val bytes_printable : bytes t

val bytes_small : bytes t

val bytes_small_of : char t -> bytes t

val string_size : ?gen:char t -> int t -> string t

val string : ?gen:char t -> string t

val string_of : char t -> string t

val string_readable : string t

deprecated see string_printable

val string_printable : string t

val small_string : ?gen:char t -> string t

val string_small : string t

val string_small_of : char t -> string t

val small_list : 'a t -> 'a list t

val flatten_l : 'a t list -> 'a list t

val flatten_a : 'a t array -> 'a array t

val flatten_opt : 'a t option -> 'a option t

val flatten_res : ('a t, 'e) Stdlib.result -> ('a, 'e) Stdlib.result t

val small_array : 'a t -> 'a array t

val join : 'a t t -> 'a t

val sized : 'a sized -> 'a t

val sized_size : int t -> 'a sized -> 'a t

val fix : (('a -> 'b t) -> 'a -> 'b t) -> 'a -> 'b t

val nat_split2 : int -> (int * int) t

val pos_split2 : int -> (int * int) t

val nat_split : size:int -> int -> int array t

val pos_split : size:int -> int -> int array t

val delay : (unit -> 'a t) -> 'a t

val generate : ?rand:Stdlib.Random.State.t -> n:int -> 'a t -> 'a list

val generate1 : ?rand:Stdlib.Random.State.t -> 'a t -> 'a

val let+ : 'a t -> ('a -> 'b) -> 'b t

val and+ : 'a t -> 'b t -> ('a * 'b) t

val let* : 'a t -> ('a -> 'b t) -> 'b t

val and* : 'a t -> 'b t -> ('a * 'b) t