package travesty

  1. Overview
  2. Docs
package travesty
Legend:
Library
Module
Module type
Parameter
Class
Class type

Extend1 implements Extensions1 for an arity-1 mappable container.

Parameters

module S : S1_container

Signature

Extensions1 includes the container extensions from T_container, as they work with any arity-1 container.

include T_container.Extensions1 with type 'a t := 'a S.t
val max_measure : measure:('a -> int) -> ?default:int -> 'a S.t -> int

max_measure ~measure ~default xs measures each item in xs according to measure, and returns the highest measure reported. If xs is empty, return default if given, and 0 otherwise.

Containers of predicates

The following functions concern containers of predicates (functions of type 'a -> bool).

val any : 'a -> predicates:('a -> bool) S.t -> bool

any x ~predicates tests x against predicates until one returns true, in which case it returns true; or all return false, in which case it returns false.

val all : 'a -> predicates:('a -> bool) S.t -> bool

any x ~predicates tests x against predicates until one returns false, in which case it returns false; or all return true, in which case it returns true.

val none : 'a -> predicates:('a -> bool) S.t -> bool

none x ~predicates is the same as any x with all predicates in predicates negated. It tests x against predicates until one returns true, in which case it returns false; or all return false, in which case it returns true.

Testing for a specific number of elements

The following functions help in checking whether a container has a particular, commonly-required number of elements (zero or one, one, two, and so on).

val at_most_one : 'a S.t -> 'a option Core_kernel.Or_error.t

at_most_one xs returns Ok None if xs is empty; Ok Some(x) if it contains only x; and an error otherwise.

Examples:

T_list.at_most_one []     (* ok None *)
       at_most_one [1]    (* ok (Some 1) *)
       at_most_one [1; 2] (* error -- too many *)
val one : 'a S.t -> 'a Core_kernel.Or_error.t

one xs returns Ok x if xs contains only x, and an error otherwise.

Examples:

T_list.one []     (* error -- not enough *)
       one [1]    (* ok 1 *)
       one [1; 2] (* error -- too many *)
val two : 'a S.t -> ('a * 'a) Core_kernel.Or_error.t

two xs returns Ok (x, y) if xs is a list containing only x and y in that order, and an error otherwise.

Examples:

T_list.two []        (* error -- not enough *)
       two [1]       (* error -- not enough *)
       two [1; 2]    (* ok (1, 2) *)
       two [1; 2; 3] (* error -- too many *)
val right_pad : padding:'a -> 'a Base.list S.t -> 'a Base.list S.t

right_pad ~padding xs pads every list in xs with padding, ensuring all lists have equal length.

Example:

right_pad ~padding:6
  [ [0; 8; 0; 0]    (* [ [ 0; 8; 0; 0; 6 ] *)
  ; [9; 9; 9]       (* ; [ 9; 9; 9; 6; 6 ] *)
  ; [8; 8; 1; 9; 9] (* ; [ 8; 8; 1; 9; 9 ] *)
  ; [9; 1; 1; 9]    (* ; [ 9; 1; 1; 9; 6 ] *)
  ; [7; 2; 5]       (* ; [ 7; 2; 5; 6; 6 ] *)
  ; [3]             (* ; [ 3; 6; 6; 6; 6 ] *)
  ]                 (* ] *)
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct