module List:sig
..end
type'a
t ='a list
=
| |
[] |
| |
:: of |
val init : int -> (int -> 'a) -> 'a list
Similar to Array.init
, init n f
returns the list containing
the results of (f 0),(f 1).... (f (n-1)).
Raise Invalid_arg "ExtList.init"
if n < 0.
Uses stdlib implementation in OCaml 4.06.0 and newer.
val make : int -> 'a -> 'a list
Similar to String.make
, make n x
returns a
* list containing n
elements x
.
val first : 'a list -> 'a
Returns the first element of the list, or raise Empty_list
if
the list is empty (similar to hd
).
val last : 'a list -> 'a
Returns the last element of the list, or raise Empty_list
if
the list is empty. This function takes linear time.
val iteri : (int -> 'a -> unit) -> 'a list -> unit
iteri f l
will call (f 0 a0);(f 1 a1) ... (f n an)
where
a0..an
are the elements of the list l
.
val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list
mapi f l
will build the list containing
(f 0 a0);(f 1 a1) ... (f n an)
where a0..an
are the elements of
the list l
.
val rfind : ('a -> bool) -> 'a list -> 'a
rfind p l
returns the last element x
of l
such as p x
returns
true
or raises Not_found
if such element as not been found.
val find_exc : ('a -> bool) -> exn -> 'a list -> 'a
find_exc p e l
returns the first element of l
such as p x
returns true
or raises e
if such element as not been found.
val findi : (int -> 'a -> bool) -> 'a list -> int * 'a
findi p e l
returns the first element ai
of l
along with its
index i
such that p i ai
is true, or raises Not_found
if no
such element has been found.
val unique : ?cmp:('a -> 'a -> bool) -> 'a list -> 'a list
unique cmp l
returns the list l
without any duplicate element.
Default comparator ( = ) is used if no comparison function specified.
val filter_map : ('a -> 'b option) -> 'a list -> 'b list
filter_map f l
call (f a0) (f a1).... (f an)
where a0..an
are
the elements of l
. It returns the list of elements bi
such as
f ai = Some bi
(when f
returns None
, the corresponding element of
l
is discarded).
val find_map_exn : ('a -> 'b option) -> 'a list -> 'b
find_map_exn pred list
finds the first element of list
for which
pred element
returns Some r
. It returns r
immediately
once found or raises Not_found
if no element matches the
predicate. See also ExtList.List.filter_map
.
This function was called find_map
prior to extlib 1.7.7, but had to
be renamed to stay compatible with OCaml 4.10.
val find_map_opt : ('a -> 'b option) -> 'a list -> 'b option
same as find_map_exn but returning option
val find_map : ('a -> 'b option) -> 'a list -> 'b option
same as find_map_opt
val split_nth : int -> 'a list -> 'a list * 'a list
split_nth n l
returns two lists l1
and l2
, l1
containing the
first n
elements of l
and l2
the others. Raise Invalid_index
if
n
is outside of l
size bounds.
val filteri : (int -> 'a -> bool) -> 'a list -> 'a list
Same as ExtList.List.filter
, but the predicate is applied to the index of
the element as first argument (counting from 0), and the element
itself as second argument.
val fold_left_map : ('a -> 'b -> 'a * 'c) -> 'a -> 'b list -> 'a * 'c list
fold_left_map
is a combination of fold_left
and map
that threads an
accumulator through calls to f
val remove : 'a list -> 'a -> 'a list
remove l x
returns the list l
without the first element x
found
or returns l
if no element is equal to x
. Elements are compared
using ( = ).
val remove_if : ('a -> bool) -> 'a list -> 'a list
remove_if cmp l
is similar to remove
, but with cmp
used
instead of ( = ).
val remove_all : 'a list -> 'a -> 'a list
remove_all l x
is similar to remove
but removes all elements that
are equal to x
and not only the first one.
val take : int -> 'a list -> 'a list
take n l
returns up to the n
first elements from list l
, if
available.
val drop : int -> 'a list -> 'a list
drop n l
returns l
without the first n
elements, or the empty
list if l
have less than n
elements.
val takewhile : ('a -> bool) -> 'a list -> 'a list
takewhile f xs
returns the first elements of list xs
which satisfy the predicate f
.
val dropwhile : ('a -> bool) -> 'a list -> 'a list
dropwhile f xs
returns the list xs
with the first
elements satisfying the predicate f
dropped.
Enumerations are important in ExtLib, they are a good way to work with abstract enumeration of elements, regardless if they are located in a list, an array, or a file.
val enum : 'a list -> 'a Enum.t
Returns an enumeration of the elements of a list.
val of_enum : 'a Enum.t -> 'a list
Build a list from an enumeration.
val cons : 'a -> 'a list -> 'a list
val assoc_opt : 'a -> ('a * 'b) list -> 'b option
val assq_opt : 'a -> ('a * 'b) list -> 'b option
val find_opt : ('a -> bool) -> 'a list -> 'a option
val nth_opt : 'a list -> int -> 'a option
val compare_lengths : 'a list -> 'b list -> int
val compare_length_with : 'a list -> int -> int
Some minor modifications have been made to the specification of some functions, especially concerning exceptions raised.
val hd : 'a list -> 'a
Returns the first element of the list or raise Empty_list
if the
list is empty.
val tl : 'a list -> 'a list
Returns the list without its first elements or raise Empty_list
if
the list is empty.
val nth : 'a list -> int -> 'a
nth l n
returns the n-th element of the list l
or raise
Invalid_index
is the index is outside of l
bounds.
val sort : ?cmp:('a -> 'a -> int) -> 'a list -> 'a list
Sort the list using optional comparator (by default compare
).
The following functions have been improved so all of them are
tail-recursive. They have also been modified so they no longer
raise Invalid_arg
but Different_list_size
when used on two
lists having a different number of elements.
val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit
val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a
val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val combine : 'a list -> 'b list -> ('a * 'b) list
The following functions have the same behavior as the List
module ones but are tail-recursive. That means they will not
cause a Stack_overflow
when used on very long list.
The implementation might be a little more slow in bytecode, but compiling in native code will not affect performances.
val map : ('a -> 'b) -> 'a list -> 'b list
val append : 'a list -> 'a list -> 'a list
val flatten : 'a list list -> 'a list
val concat : 'a list list -> 'a list
val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
val split : ('a * 'b) list -> 'a list * 'b list
The following functions were already tail-recursive in the List
module but were using List.rev
calls. The new implementations
have better performances.
val filter : ('a -> bool) -> 'a list -> 'a list
val find_all : ('a -> bool) -> 'a list -> 'a list
val partition : ('a -> bool) -> 'a list -> 'a list * 'a list
These functions are already part of the Ocaml standard library and have not been modified. Please refer to the Ocaml Manual for documentation.
val length : 'a list -> int
val rev_append : 'a list -> 'a list -> 'a list
val rev : 'a list -> 'a list
val rev_map : ('a -> 'b) -> 'a list -> 'b list
val iter : ('a -> unit) -> 'a list -> unit
val fold_left : ('b -> 'a -> 'b) -> 'b -> 'a list -> 'b
val for_all : ('a -> bool) -> 'a list -> bool
val exists : ('a -> bool) -> 'a list -> bool
val find : ('a -> bool) -> 'a list -> 'a
val mem : 'a -> 'a list -> bool
val memq : 'a -> 'a list -> bool
val assoc : 'a -> ('a * 'b) list -> 'b
val assq : 'a -> ('a * 'b) list -> 'b
val mem_assoc : 'a -> ('a * 'b) list -> bool
val mem_assq : 'a -> ('a * 'b) list -> bool
val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list
val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list
val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list
Same as ExtList.List.sort
, but also remove duplicates.
val to_seq : 'a list -> 'a Stdlib.Seq.t
*_seq
functions were introduced in OCaml 4.07.0, and are _not_ implemented in extlib for older OCaml versions
val of_seq : 'a Stdlib.Seq.t -> 'a list
val concat_map : ('a -> 'b list) -> 'a list -> 'b list
val equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool
equal eq [a1; ...; an] [b1; ..; bm]
holds when
the two input lists have the same length, and for each
pair of elements ai
, bi
at the same position we have
eq ai bi
.
Note: the eq
function may be called even if the
lists have different length. If you know your equality
function is costly, you may want to check ExtList.List.compare_lengths
first.
val compare : ('a -> 'a -> int) -> 'a list -> 'a list -> int
compare cmp [a1; ...; an] [b1; ...; bm]
performs
a lexicographic comparison of the two input lists,
using the same 'a -> 'a -> int
interface as Stdlib.compare
:
a1 :: l1
is smaller than a2 :: l2
(negative result)
if a1
is smaller than a2
, or if they are equal (0 result)
and l1
is smaller than l2
[]
is strictly smaller than non-empty listsNote: the cmp
function will be called even if the lists have
different lengths.
exception Empty_list
Empty_list
is raised when an operation applied on an empty list
is invalid : hd
for example.
exception Invalid_index of int
Invalid_index
is raised when an indexed access on a list is
out of list bounds.
exception Different_list_size of string
Different_list_size
is raised when applying functions such as
iter2
on two lists having different size.