package clarity

You can search for identifiers within the package.

in-package search v0.2.0

package clarity

clarity
- Clarity
  - Align
    
    Basic
    
    Basic2
    
    Basic3
    
    Make
    
    A
    
    Make2
    
    A
    
    Make3
    
    A
    
    S
    
    S2
    
    S3
  - Applicative
    
    Basic
    
    Basic2
    
    Basic3
    
    Make
    
    A
    
    Make2
    
    A
    
    Make3
    
    A
    
    S
    
    S2
    
    S3
  - Caml
  - Either
  - Fn
  - Foldable
    
    Basic
    
    M
    
    M2
    
    M3
    
    Make
    
    F
    
    S
  - Functor
    
    Basic
    
    Basic2
    
    Basic3
    
    Make
    
    F
    
    Make2
    
    F
    
    Make3
    
    F
    
    S
    
    S2
    
    S3
  - Id
  - Internal
    
    Vector
    
    A
    
    A
    
    A2
    
    A
    
    A3
    
    A
    
    AP
    
    Arr
    
    Concatenation
    
    M
    
    M
    
    M2
    
    M
    
    M3
    
    M
  - List
    
    A
    
    A
    
    A2
    
    A
    
    A3
    
    A
    
    M
    
    M
    
    M2
    
    M
    
    M3
    
    M
  - Monad
    
    Basic
    
    Basic2
    
    Basic3
    
    Make
    
    M
    
    Make2
    
    M
    
    Make3
    
    M
    
    S
    
    S2
    
    S3
  - Monoid
    
    All
    
    Any
    
    Dual
    
    M
    
    Endo
    
    T
    
    Int
    
    Max
    
    Min
    
    Product
    
    Sum
    
    Opt
    
    S
    
    Pair
    
    M1
    
    M2
    
    S
  - Option
  - Reader
  - Semigroup
    
    First
    
    T
    
    Last
    
    T
    
    S
  - State
  - These
    
    Make
    
    S
  - Traversable
    
    Basic
    
    Basic2
    
    Basic3
    
    Make
    
    T
    
    Make2
    
    T
    
    Make3
    
    T
    
    S
    
    S2
    
    S3
  - Validation
    
    Make
    
    S
  - Vector
    
    A
    
    A
    
    A2
    
    A
    
    A3
    
    A
    
    M
    
    M
    
    M2
    
    M
    
    M3
    
    M
  - Void
  - Writer
    
    Make
    
    M

Legend:
Library
Module
Module type
Parameter
Class
Class type

module Arr : sig ... end

module AP : sig ... end

val ceil_div : int -> int -> int

val _BITS : int

val _BRANCHING : int

val _EXTRA_STEPS : int

val _SKIP_SIZE : int

val check_depth : int -> unit

type 'a t =

| Leaf of 'a array
| R_node of int array * 'a t array
| B_node of 'a t array

val depth : 'a t -> int

val length : 'a t -> int

val update_lengths : 'a t -> unit

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

val rr_search : int array -> int -> int -> int * int

val radix_search : int -> int -> int * int

val max_nodes_allowed : int -> int

val empty : 'a t

val get_leaf : 'a t -> 'a array

val get_rnode : 'a t -> int array * 'a t array

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

val node_len : 'a. 'a t -> int

module Concatenation : sig ... end

val append : 'a t -> 'a t -> 'a t

exception Out_of_bounds of {

index : int;
size : int;

}

val check_bounds : 'a t -> int -> unit

val get : 'a. 'a t -> int -> 'a

val update : 'a. 'a t -> int -> 'a -> 'a t

val split_at : 'a. 'a t -> int -> 'a t * 'a t

val take : 'a. 'a t -> int -> 'a t

val drop : 'a. 'a t -> int -> 'a t

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

val make_pb : unit -> ('a -> unit) * (unit -> 'a t)

val init : 'a. int -> (int -> 'a) -> 'a t

include sig ... end

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

val pure : 'a -> 'a t

val ap : ('a -> 'b) t -> (unit -> 'a t) -> 'b t

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

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

val replace : 'a -> 'b t -> 'a t

val void : 'a t -> unit t

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

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

val (<~>) : ('a -> 'b) t -> (unit -> 'a t) -> 'b t

val discard_left : 'a t -> (unit -> 'b t) -> 'b t

val discard_right : 'a t -> (unit -> 'b t) -> 'a t

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

val repeat_ : int -> 'a t -> unit t

val forever : 'a t -> 'b t

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

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

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

include sig ... end

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

val foldr : ('a -> (unit -> 'b) -> 'b) -> (unit -> 'b) -> 'a t -> 'b

val fold_map : (module Monoid.S with type t = 'm) -> ('a -> 'm) -> 'a t -> 'm

val any : ('a -> bool) -> 'a t -> bool

val all : ('a -> bool) -> 'a t -> bool

val find : ('a -> bool) -> 'a t -> 'a option

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

val to_list : 'a t -> 'a list

val of_list : 'a list -> 'a t

include sig ... end

val align_with : (('a, 'b) These.t -> 'c) -> 'a t -> 'b t -> 'c t

val align : 'a t -> 'b t -> ('a, 'b) These.t t

val falign : ('a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t

val pad_zip_with : ('a option -> 'b option -> 'c) -> 'a t -> 'b t -> 'c t

val pad_zip : 'a t -> 'b t -> ('a option * 'b option) t

module A3 (A : Applicative.Basic3) : sig ... end

module A2 (A : Applicative.Basic2) : sig ... end

module A (A : Applicative.Basic) : sig ... end

module M3 (M : Monad.Basic3) : sig ... end

module M2 (M : Monad.Basic2) : sig ... end

module M (M : Monad.Basic) : sig ... end