package devkit
Install
Dune Dependency
Authors
Maintainers
Sources
sha256=222f8ac131b1d970dab7eeb2714bfd6b9338b88b1082e6e01c136ae19e7eaef4
sha512=c9e6d93e3d21e5530c0f4d5baca51bf1f0a5d19248f8af7678d0665bb5cdf295d7aaaaa3e50eb2e44b8720e55097cc675af4dc8ec45acf9da39feb3eae1405d5
doc/devkit.core/Devkit_core/ExtEnum/index.html
Module Devkit_core.ExtEnum
Source
Extensions to Enum
include module type of Enum with type 'a t = 'a Enum.t
Final functions
These functions consume the enumeration until it ends or an exception is raised by the first argument function.
iter f e
calls the function f
with each elements of e
in turn.
iter2 f e1 e2
calls the function f
with the next elements of e
and e2
repeatedly until one of the two enumerations ends.
fold f v e
returns v
if e
is empty, otherwise f aN (... (f a2 (f a1 v)) ...)
where a1..N are the elements of e
.
fold2
is similar to fold
but will fold over two enumerations at the same time until one of the two enumerations ends.
Indexed functions : these functions are similar to previous ones except that they call the function with one additional argument which is an index starting at 0 and incremented after each call to the function.
Useful functions
find f e
returns the first element x
of e
such that f x
returns true
, consuming the enumeration up to and including the found element, or, raises Not_found
if no such element exists in the enumeration, consuming the whole enumeration in the search.
Since find
consumes a prefix of the enumeration, it can be used several times on the same enumeration to find the next element.
peek e
returns None
if e
is empty or Some x
where x
is the next element of e
. The element is not removed from the enumeration.
get e
returns None
if e
is empty or Some x
where x
is the next element of e
, in which case the element is removed from the enumeration.
clone e
creates a new enumeration that is copy of e
. If e
is consumed by later operations, the clone will not get affected.
force e
forces the application of all lazy functions and the enumeration of all elements, exhausting the enumeration.
An efficient intermediate data structure of enumerated elements is constructed and e
will now enumerate over that data structure.
Lazy constructors
These functions are lazy which means that they will create a new modified enumeration without actually enumerating any element until they are asked to do so by the programmer (using one of the functions above).
When the resulting enumerations of these functions are consumed, the underlying enumerations they were created from are also consumed.
map f e
returns an enumeration over (f a1, f a2, ... , f aN)
where a1...N are the elements of e
.
mapi
is similar to map
except that f
is passed one extra argument which is the index of the element in the enumeration, starting from 0.
filter f e
returns an enumeration over all elements x
of e
such as f x
returns true
.
filter_map f e
returns an enumeration over all elements x
such as f y
returns Some x
, where y
is an element of e
.
append e1 e2
returns an enumeration that will enumerate over all elements of e1
followed by all elements of e2
.
concat e
returns an enumeration over all elements of all enumerations of e
.
Constructors
In this section the word shall denotes a semantic requirement. The correct operation of the functions in this interface are conditional on the client meeting these requirements.
This exception shall be raised by the next
function of make
or from
when no more elements can be enumerated, it shall not be raised by any function which is an argument to any other function specified in the interface.
This function creates a fully defined enumeration.
- the
next
function shall return the next element of the enumeration or raiseNo_more_elements
if the underlying data structure does not have any more elements to enumerate. - the
count
function shall return the actual number of remaining elements in the enumeration. - the
clone
function shall create a clone of the enumeration such as operations on the original enumeration will not affect the clone.
For some samples on how to correctly use make
, you can have a look at implementation of ExtList.enum
.
from next
creates an enumeration from the next
function. next
shall return the next element of the enumeration or raise No_more_elements
when no more elements can be enumerated. Since the enumeration definition is incomplete, a call to clone
or count
will result in a call to force
that will enumerate all elements in order to return a correct value.
init n f
creates a new enumeration over elements f 0, f 1, ..., f (n-1)
Counting
count e
returns the number of remaining elements in e
without consuming the enumeration.
Depending of the underlying data structure that is implementing the enumeration functions, the count operation can be costly, and even sometimes can cause a call to force
.
same as Enum.find
, but found element is peeked, not junked
val join :
?left:bool ->
?right:bool ->
?multi:bool ->
('a -> 'b -> int) ->
'a t ->
'b t ->
('a option * 'b option) t
merge two enums of different types
val merge_assoc :
('a -> 'a -> int) ->
('a * 'b) t ->
('a * 'c) t ->
('a * 'b option * 'c option) t
merge two enums over key-value pairs
group equal fold zero e
accumulates elements of e
with fold
, first element is fold
ed with zero
, at each subsequent step equal
is checked, and new accumulator is started once it returns false
group_assoc equal fold zero e
accumulates (with fold
) values in e
with matching key as determined by comparison function equal
, first value is fold
ed with zero
, e.g.:
List.of_enum @@ Enum.group_assoc (=) (+) 0 @@ List.enum ["a",1; "a",2; "b",3; "b",4; "a", 1; "a", 10] = ["a", 3; "b", 7; "a", 11; ]
uniq f e
replaces every consecuitive sequence of elements from e
comparing equal by the given comparison function f
with the first element from that sequence
count_unique f e
replaces every consecutive sequence of elements from e
comparing equal by the given comparison function f
with the first element from that sequence and the number of duplicates
sub e f
extracts a subenum (consecutive sequence of the elements from e
) that map to the same value of f