package ppx_hardcaml

You can search for identifiers within the package.

in-package search v0.2.0

ppx_hardcaml
- Library ppx_hardcaml
  - Ppx_hardcaml
    
    Ppx_hardcaml_zero
- Library ppx_hardcaml.runtime
  - Ppx_hardcaml_runtime
    
    Array
    
    Int
    
    Interface
    
    List
- Sources
  - ppx_hardcaml
    
    ppx_hardcaml.ml
  - ppx_hardcaml.runtime
    
    ppx_hardcaml_runtime.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Ppx_hardcaml_runtime.Array`Source

include module type of struct include Base.Array end

Sourcetype 'a t = 'a array

Sourceval compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int

Sourceval compare__local : ('a -> 'a -> int) -> 'a t -> 'a t -> int

Sourceval globalize : ('a -> 'a) -> 'a t -> 'a t

include Sexplib0.Sexpable.S1 with type 'a t := 'a t

Sourceval t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a t

Sourceval sexp_of_t : ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.t

Sourceval t_sexp_grammar : 'a Sexplib0.Sexp_grammar.t -> 'a t Sexplib0.Sexp_grammar.t

include Base.Binary_searchable.S1 with type 'a t := 'a t

Source

val binary_search : 
  ?pos:int ->
  ?len:int ->
  'a t ->
  compare:('a -> 'key -> int) ->
  [ `Last_strictly_less_than
  | `Last_less_than_or_equal_to
  | `Last_equal_to
  | `First_equal_to
  | `First_greater_than_or_equal_to
  | `First_strictly_greater_than ] ->
  'key ->
  int option

Source

val binary_search_segmented : 
  ?pos:int ->
  ?len:int ->
  'a t ->
  segment_of:('a -> [ `Left | `Right ]) ->
  [ `Last_on_left | `First_on_right ] ->
  int option

include Base.Indexed_container.S1_with_creators with type 'a t := 'a t

include Base.Container.S1_with_creators with type 'a t := 'a t

Returns the sum of f i for all i in the container.

Sourceval of_list : 'a list -> 'a t

Sourceval of_array : 'a array -> 'a t

Sourceval append : 'a t -> 'a t -> 'a t

E.g., append (of_list [1; 2]) (of_list [3; 4; 5]) is of_list [1; 2; 3; 4; 5]

Sourceval map : 'a t -> f:('a -> 'b) -> 'b t

map f (of_list [a1; ...; an]) applies f to a1, a2, ..., an, in order, and builds a result equivalent to of_list [f a1; ...; f an].

Sourceval filter : 'a t -> f:('a -> bool) -> 'a t

filter t ~f returns all the elements of t that satisfy the predicate f.

Sourceval filter_map : 'a t -> f:('a -> 'b option) -> 'b t

filter_map t ~f applies f to every x in t. The result contains every y for which f x returns Some y.

Sourceval concat_map : 'a t -> f:('a -> 'b t) -> 'b t

concat_map t ~f is equivalent to concat (map t ~f).

Sourceval partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t

partition_tf t ~f returns a pair t1, t2, where t1 is all elements of t that satisfy f, and t2 is all elements of t that do not satisfy f. The "tf" suffix is mnemonic to remind readers that the result is (trues, falses).

Sourceval partition_map : 'a t -> f:('a -> ('b, 'c) Base__.Either0.t) -> 'b t * 'c t

partition_map t ~f partitions t according to f.

include Base.Container.S1 with type 'a t := 'a t

Sourceval mem : 'a t -> 'a -> equal:('a -> 'a -> bool) -> bool

Checks whether the provided element is there, using equal.

Sourceval is_empty : 'a t -> bool

Sourceval iter : 'a t -> f:('a -> unit) -> unit

Sourceval fold : 'a t -> init:'acc -> f:('acc -> 'a -> 'acc) -> 'acc

fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en, where e1..en are the elements of t

Source

val fold_result : 
  'a t ->
  init:'acc ->
  f:('acc -> 'a -> ('acc, 'e) Base.Result.t) ->
  ('acc, 'e) Base.Result.t

fold_result t ~init ~f is a short-circuiting version of fold that runs in the Result monad. If f returns an Error _, that value is returned without any additional invocations of f.

Source

val fold_until : 
  'a t ->
  init:'acc ->
  f:('acc -> 'a -> ('acc, 'final) Base.Container.Continue_or_stop.t) ->
  finish:('acc -> 'final) ->
  'final

fold_until t ~init ~f ~finish is a short-circuiting version of fold. If f returns Stop _ the computation ceases and results in that value. If f returns Continue _, the fold will proceed. If f never returns Stop _, the final result is computed by finish.

Example:

  type maybe_negative =
    | Found_negative of int
    | All_nonnegative of { sum : int }

  (** [first_neg_or_sum list] returns the first negative number in [list], if any,
      otherwise returns the sum of the list. *)
  let first_neg_or_sum =
    List.fold_until ~init:0
      ~f:(fun sum x ->
        if x < 0
        then Stop (Found_negative x)
        else Continue (sum + x))
      ~finish:(fun sum -> All_nonnegative { sum })
  ;;

  let x = first_neg_or_sum [1; 2; 3; 4; 5]
  val x : maybe_negative = All_nonnegative {sum = 15}

  let y = first_neg_or_sum [1; 2; -3; 4; 5]
  val y : maybe_negative = Found_negative -3

Sourceval exists : 'a t -> f:('a -> bool) -> bool

Returns true if and only if there exists an element for which the provided function evaluates to true. This is a short-circuiting operation.

Sourceval for_all : 'a t -> f:('a -> bool) -> bool

Returns true if and only if the provided function evaluates to true for all elements. This is a short-circuiting operation.

Sourceval count : 'a t -> f:('a -> bool) -> int

Returns the number of elements for which the provided function evaluates to true.

Returns the sum of f i for all i in the container.

Source

val sum : 
  (module Base.Container.Summable with type t = 'sum) ->
  'a t ->
  f:('a -> 'sum) ->
  'sum

Sourceval find : 'a t -> f:('a -> bool) -> 'a option

Returns as an option the first element for which f evaluates to true.

Sourceval find_map : 'a t -> f:('a -> 'b option) -> 'b option

Returns the first evaluation of f that returns Some, and returns None if there is no such element.

Sourceval to_list : 'a t -> 'a list

Sourceval to_array : 'a t -> 'a array

Sourceval min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option

Returns a minimum (resp maximum) element from the collection using the provided compare function, or None if the collection is empty. In case of a tie, the first element encountered while traversing the collection is returned. The implementation uses fold so it has the same complexity as fold.

Sourceval max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option

These are all like their equivalents in Container except that an index starting at 0 is added as the first argument to f.

Sourceval foldi : 'a t -> init:_ -> f:(int -> _ -> 'a -> _) -> _

Sourceval iteri : 'a t -> f:(int -> 'a -> unit) -> unit

Sourceval existsi : 'a t -> f:(int -> 'a -> bool) -> bool

Sourceval for_alli : 'a t -> f:(int -> 'a -> bool) -> bool

Sourceval counti : 'a t -> f:(int -> 'a -> bool) -> int

Sourceval findi : 'a t -> f:(int -> 'a -> bool) -> (int * 'a) option

Sourceval find_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b option

Sourceval init : int -> f:(int -> 'a) -> 'a t

init n ~f is equivalent to of_list [f 0; f 1; ...; f (n-1)]. It raises an exception if n < 0.

Sourceval mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t

mapi is like map. Additionally, it passes in the index of each element as the first argument to the mapped function.

Sourceval filteri : 'a t -> f:(int -> 'a -> bool) -> 'a t

Sourceval filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t

filter_mapi is like filter_map. Additionally, it passes in the index of each element as the first argument to the mapped function.

Sourceval concat_mapi : 'a t -> f:(int -> 'a -> 'b t) -> 'b t

concat_mapi t ~f is like concat_map. Additionally, it passes the index as an argument.

include Base.Invariant.S1 with type 'a t := 'a t

Sourceval invariant : ('a -> unit) -> 'a t -> unit

Sourceval max_length : int

Maximum length of a normal array. The maximum length of a float array is max_length/2 on 32-bit machines and max_length on 64-bit machines.

Sourceval length : 'a t -> int

Sourceval get : 'a t -> int -> 'a

Array.get a n returns the element number n of array a. The first element has number 0. The last element has number Array.length a - 1. You can also write a.(n) instead of Array.get a n.

Raise Invalid_argument "index out of bounds" if n is outside the range 0 to (Array.length a - 1).

Sourceval set : 'a t -> int -> 'a -> unit

Array.set a n x modifies array a in place, replacing element number n with x. You can also write a.(n) <- x instead of Array.set a n x.

Raise Invalid_argument "index out of bounds" if n is outside the range 0 to Array.length a - 1.

Sourceval unsafe_get : 'a t -> int -> 'a

Unsafe version of get. Can cause arbitrary behavior when used for an out-of-bounds array access.

Sourceval unsafe_set : 'a t -> int -> 'a -> unit

Unsafe version of set. Can cause arbitrary behavior when used for an out-of-bounds array access.

Sourceval create : len:int -> 'a -> 'a t

create ~len x creates an array of length len with the value x populated in each element.

Sourceval create_local : len:int -> 'a -> 'a t

create_local ~len x is like create. It allocates the array on the local stack. The array's elements are still global.

Sourceval create_float_uninitialized : len:int -> float t

create_float_uninitialized ~len creates a float array of length len with uninitialized elements -- that is, they may contain arbitrary, nondeterministic float values. This can be significantly faster than using create, when unboxed float array representations are enabled.

Sourceval make_matrix : dimx:int -> dimy:int -> 'a -> 'a t t

Array.make_matrix dimx dimy e returns a two-dimensional array (an array of arrays) with first dimension dimx and second dimension dimy. All the elements of this new matrix are initially physically equal to e. The element (x,y) of a matrix m is accessed with the notation m.(x).(y).

Raise Invalid_argument if dimx or dimy is negative or greater than Array.max_length.

If the value of e is a floating-point number, then the maximum size is only Array.max_length / 2.

Sourceval copy_matrix : 'a t t -> 'a t t

Array.copy_matrix t returns a fresh copy of the array of arrays t. This is typically used when t is a matrix created by Array.make_matrix.

Sourceval concat : 'a t list -> 'a t

Like Array.append, but concatenates a list of arrays.

Sourceval copy : 'a t -> 'a t

Array.copy a returns a copy of a, that is, a fresh array containing the same elements as a.

Sourceval fill : 'a t -> pos:int -> len:int -> 'a -> unit

Array.fill a ofs len x modifies the array a in place, storing x in elements number ofs to ofs + len - 1.

Raise Invalid_argument "Array.fill" if ofs and len do not designate a valid subarray of a.

Array.blit v1 o1 v2 o2 len copies len elements from array v1, starting at element number o1, to array v2, starting at element number o2. It works correctly even if v1 and v2 are the same array, and the source and destination chunks overlap.

Raise Invalid_argument "Array.blit" if o1 and len do not designate a valid subarray of v1, or if o2 and len do not designate a valid subarray of v2.

int_blit and float_blit provide fast bound-checked blits for immediate data types. The unsafe versions do not bound-check the arguments.

include Base.Blit.S1 with type 'a t := 'a t

Source

val blit : 
  src:'a t ->
  src_pos:int ->
  dst:'a t ->
  dst_pos:int ->
  len:int ->
  unit

Source

val blito : 
  src:'a t ->
  ?src_pos:int ->
  ?src_len:int ->
  dst:'a t ->
  ?dst_pos:int ->
  unit ->
  unit

Source

val unsafe_blit : 
  src:'a t ->
  src_pos:int ->
  dst:'a t ->
  dst_pos:int ->
  len:int ->
  unit

Sourceval sub : 'a t -> pos:int -> len:int -> 'a t

Sourceval subo : ?pos:int -> ?len:int -> 'a t -> 'a t

Sourceval folding_map : 'a t -> init:'acc -> f:('acc -> 'a -> 'acc * 'b) -> 'b t

folding_map is a version of map that threads an accumulator through calls to f.

Source

val folding_mapi : 
  'a t ->
  init:'acc ->
  f:(int -> 'acc -> 'a -> 'acc * 'b) ->
  'b t

Sourceval fold_map : 'a t -> init:'acc -> f:('acc -> 'a -> 'acc * 'b) -> 'acc * 'b t

Array.fold_map is a combination of Array.fold and Array.map that threads an accumulator through calls to f.

Source

val fold_mapi : 
  'a t ->
  init:'acc ->
  f:(int -> 'acc -> 'a -> 'acc * 'b) ->
  'acc * 'b t

Sourceval fold_right : 'a t -> f:('a -> 'acc -> 'acc) -> init:'acc -> 'acc

Array.fold_right f a ~init computes f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)), where n is the length of the array a.

All sort functions in this module sort in increasing order by default.

Sourceval sort : ?pos:int -> ?len:int -> 'a t -> compare:('a -> 'a -> int) -> unit

sort uses constant heap space. stable_sort uses linear heap space.

To sort only part of the array, specify pos to be the index to start sorting from and len indicating how many elements to sort.

Sourceval stable_sort : 'a t -> compare:('a -> 'a -> int) -> unit

Sourceval is_sorted : 'a t -> compare:('a -> 'a -> int) -> bool

Sourceval is_sorted_strictly : 'a t -> compare:('a -> 'a -> int) -> bool

is_sorted_strictly xs ~compare iff is_sorted xs ~compare and no two consecutive elements in xs are equal according to compare.

Sourceval merge : 'a t -> 'a t -> compare:('a -> 'a -> int) -> 'a t

Merges two arrays: assuming that a1 and a2 are sorted according to the comparison function compare, merge a1 a2 ~compare will return a sorted array containing all the elements of a1 and a2. If several elements compare equal, the elements of a1 will be before the elements of a2.

Sourceval partitioni_tf : 'a t -> f:(int -> 'a -> bool) -> 'a t * 'a t

Sourceval cartesian_product : 'a t -> 'b t -> ('a * 'b) t

Sourceval transpose : 'a t t -> 'a t t option

transpose in the sense of a matrix transpose. It returns None if the arrays are not all the same length.

Sourceval transpose_exn : 'a t t -> 'a t t

Sourceval filter_opt : 'a option t -> 'a t

filter_opt array returns a new array where None entries are omitted and Some x entries are replaced with x. Note that this changes the index at which elements will appear.

Functions with the 2 suffix raise an exception if the lengths of the two given arrays aren't the same.

Sourceval iter2_exn : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit

Sourceval map2_exn : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t

Source

val fold2_exn : 
  'a t ->
  'b t ->
  init:'acc ->
  f:('acc -> 'a -> 'b -> 'acc) ->
  'acc

Sourceval for_all2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool

for_all2_exn t1 t2 ~f fails if length t1 <> length t2.

Sourceval exists2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool

exists2_exn t1 t2 ~f fails if length t1 <> length t2.

Sourceval swap : 'a t -> int -> int -> unit

swap arr i j swaps the value at index i with that at index j.

Sourceval rev_inplace : 'a t -> unit

rev_inplace t reverses t in place.

Sourceval rev : 'a t -> 'a t

rev t returns a reversed copy of t

Sourceval of_list_rev : 'a list -> 'a t

of_list_rev l converts from list then reverses in place.

Sourceval of_list_map : 'a list -> f:('a -> 'b) -> 'b t

of_list_map l ~f is the same as of_list (List.map l ~f).

Sourceval of_list_mapi : 'a list -> f:(int -> 'a -> 'b) -> 'b t

of_list_mapi l ~f is the same as of_list (List.mapi l ~f).

Sourceval of_list_rev_map : 'a list -> f:('a -> 'b) -> 'b t

of_list_rev_map l ~f is the same as of_list (List.rev_map l ~f).

Sourceval of_list_rev_mapi : 'a list -> f:(int -> 'a -> 'b) -> 'b t

of_list_rev_mapi l ~f is the same as of_list (List.rev_mapi l ~f).

Sourceval map_inplace : 'a t -> f:('a -> 'a) -> unit

Modifies an array in place, applying f to every element of the array

Sourceval find_exn : 'a t -> f:('a -> bool) -> 'a

find_exn f t returns the first a in t for which f t.(i) is true. It raises Stdlib.Not_found or Not_found_s if there is no such a.

Sourceval find_map_exn : 'a t -> f:('a -> 'b option) -> 'b

Returns the first evaluation of f that returns Some. Raises Stdlib.Not_found or Not_found_s if f always returns None.

Sourceval findi_exn : 'a t -> f:(int -> 'a -> bool) -> int * 'a

findi_exn t f returns the first index i of t for which f i t.(i) is true. It raises Stdlib.Not_found or Not_found_s if there is no such element.

Sourceval find_mapi_exn : 'a t -> f:(int -> 'a -> 'b option) -> 'b

find_mapi_exn is like find_map_exn but passes the index as an argument.

Source

val find_consecutive_duplicate : 
  'a t ->
  equal:('a -> 'a -> bool) ->
  ('a * 'a) option

find_consecutive_duplicate t ~equal returns the first pair of consecutive elements (a1, a2) in t such that equal a1 a2. They are returned in the same order as they appear in t.

Sourceval reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a option

reduce f [a1; ...; an] is Some (f (... (f (f a1 a2) a3) ...) an). Returns None on the empty array.

Sourceval reduce_exn : 'a t -> f:('a -> 'a -> 'a) -> 'a

Source

val permute : 
  ?random_state:Base.Random.State.t ->
  ?pos:int ->
  ?len:int ->
  'a t ->
  unit

permute ?random_state ?pos ?len t randomly permutes t in place.

To permute only part of the array, specify pos to be the index to start permuting from and len indicating how many elements to permute.

permute side-effects random_state by repeated calls to Random.State.int. If random_state is not supplied, permute uses Random.State.default.

Sourceval random_element : ?random_state:Base.Random.State.t -> 'a t -> 'a option

random_element ?random_state t is None if t is empty, else it is Some x for some x chosen uniformly at random from t.

random_element side-effects random_state by calling Random.State.int. If random_state is not supplied, random_element uses Random.State.default.

Sourceval random_element_exn : ?random_state:Base.Random.State.t -> 'a t -> 'a

Sourceval zip : 'a t -> 'b t -> ('a * 'b) t option

zip is like List.zip, but for arrays.

Sourceval zip_exn : 'a t -> 'b t -> ('a * 'b) t

Sourceval unzip : ('a * 'b) t -> 'a t * 'b t

unzip is like List.unzip, but for arrays.

Sourceval sorted_copy : 'a t -> compare:('a -> 'a -> int) -> 'a t

sorted_copy ar compare returns a shallow copy of ar that is sorted. Similar to List.sort

Sourceval last : 'a t -> 'a

Sourceval equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool

Sourceval equal__local : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool

Sourceval to_sequence : 'a t -> 'a Base.Sequence.t

The input array is copied internally so that future modifications of it do not change the sequence.

Sourceval to_sequence_mutable : 'a t -> 'a Base.Sequence.t

The input array is shared with the sequence and modifications of it will result in modification of the sequence.

Sourceval for_ : int -> f:(int -> 'a) -> unit

package ppx_hardcaml

Module Ppx_hardcaml_runtime.ArraySource

Module `Ppx_hardcaml_runtime.Array`Source