package batteries

  1. Overview
  2. Docs
A community-maintained standard library extension

Install 

dune-project
 Dependency

github.com Readme Edit opam file Versions (15)

Authors

  1. O
    OCaml batteries-included team

Maintainers

  1. C
    Cedric Cellier <rixed@happyleptic.org>
  2. F
    Francois Berenger <unixjunkie@sdf.org>
  3. Gabriel Scherer
  4. T
    Thibault Suzanne <thi.suzanne@gmail.com>
  5. S
    Simmo Saan <simmo.saan@gmail.com>

Sources

v3.9.0.tar.gz
md5=ea26b5c72e6731e59d856626049cca4d
sha512=55975b62c26f6db77433a3ac31f97af609fc6789bb62ac38b267249c78fd44ff37fe81901f1cf560857b9493a6046dd37b0d1c0234c66bd59e52843aac3ce6cb

doc/batteries.unthreaded/BatIMap/index.html

Module BatIMapSource

DIET Maps from integers, packed using ranges

Sourcetype 'a t
Sourcetype key = int
Sourceval empty : eq:('a -> 'a -> bool) -> 'a t

The empty map. Needs one parameter: a comparison function for the values, to enable merging of ranges with identical values.

Sourceval singleton : eq:('a -> 'a -> bool) -> int -> 'a -> 'a t
Sourceval is_empty : 'a t -> bool

Test whether a map is empty (i.e. has no bindings)

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

add x y t adds a binding from x to y in t, returning a new map.

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

add_range lo hi y t adds bindings to y for all values in the range lo,hi, returning a new map

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

find x t returns the y that is bound to x in t.

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

modify x f t replaces the y that is bound to x in t by f y.

  • since 2.1
Sourceval modify_def : 'a -> int -> ('a -> 'a) -> 'a t -> 'a t

modify_def dft x f t does the same as modify x f t but binds x to f dft if x was not bound.

  • since 2.1
Sourceval modify_opt : int -> ('a option -> 'a option) -> 'a t -> 'a t

modify_opt x f t allows to modify the binding for x in t or absence thereof.

  • since 2.1
Sourceval remove : int -> 'a t -> 'a t

Remove any bindings from the given value.

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

Remove any bindings within the given range

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

Return the sub-map of bindings in the range x,max_int

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

Return the sub-map of bindings in the range x+1,max_int

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

Return the sub-map of bindings in the range min_int, x

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

Return the sub-map of bindings in the range min_int, x-1

Sourceval mem : int -> 'a t -> bool

Test whether there is a binding from the given int

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

iter f t calls f on every binding

Sourceval iter_range : (int -> int -> 'a -> unit) -> 'a t -> unit

iter_range f t calls f on every contiguous range. For maps, contiguous ranges must map to the same y

Sourceval map : ?eq:('b -> 'b -> bool) -> ('a -> 'b) -> 'a t -> 'b t

Create a new map by modifying each y by the given function. This will not create new ranges; the mapping function is only applied to each contiguous range once. It is not applied to the ranges in order. ~eq defaults to (=).

Sourceval mapi : ?eq:('b -> 'b -> bool) -> (int -> 'a -> 'b) -> 'a t -> 'b t

Create a new map by computing new values based on key and value of the existing bindings. This can create new ranges, as adjacent bindings can be assigned different values. ~eq defaults to (=).

Sourceval map_range : ?eq:('b -> 'b -> bool) -> (int -> int -> 'a -> 'b) -> 'a t -> 'b t

Create a new map by modifying each y using the given function. This will not create new ranges, but will have access to the lo,hi of the current range. ~eq defaults to (=).

Sourceval fold : (int -> 'b -> 'a -> 'a) -> 'b t -> 'a -> 'a

fold f t x0 folds all the bindings of t into x0 using f to merge.

Sourceval fold_range : (int -> int -> 'b -> 'a -> 'a) -> 'b t -> 'a -> 'a

fold_range f t x0 folds all the contiguous ranges of t into x0 using f to merge. The order of foldings is unspecified.

Sourceval set_to_map : ?eq:('a -> 'a -> bool) -> BatISet.t -> 'a -> 'a t

set_to_map s x returns a map where every element of s is bound to x.

Sourceval domain : 'a t -> BatISet.t

domain t returns the set of ints that are bound in t

Sourceval map_to_set : ('a -> bool) -> 'a t -> BatISet.t

map_to_set p t returns the set of keys of t where p evaluates as true

Sourceval enum : 'a t -> (int * int * 'a) BatEnum.t

enum t returns an enumeration of the bindings in t

Sourceval of_enum : eq:('a -> 'a -> bool) -> (int * int * 'a) BatEnum.t -> 'a t

of_enum e returns the set of given ranges

Sourceval fold2_range : (int -> int -> 'a option -> 'b option -> 'c -> 'c) -> 'a t -> 'b t -> 'c -> 'c

fold2_range f t u x0 folds across each range that's defined in either t or u or both, giving that range and the possible values to f to merge with x0.

Example: let union_first = fold2_range (fun _lo _hi a b = match a,b with Some x,_ -> x | _,Some y -> y)

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

Merge two maps, giving a value

Sourceval merge : ?eq:('c -> 'c -> bool) -> (int -> int -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
Sourceval forall2_range : (int -> int -> 'a option -> 'b option -> bool) -> 'a t -> 'b t -> bool
Sourceval get_dec_eq : 'a t -> 'a -> 'a -> bool

Get the equality function used in an IMap.t

Sourcemodule Infix : sig ... end

Infix operators over a BatIMap