package spotlib

  1. Overview
  2. Docs
package spotlib
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module Spotlib.XlistSource

Type

Sourcetype 'a t = 'a list

Construction

Sourceval empty : 'a t

empty = []

Sourceval singleton : 'a -> 'a t

singleton x = [x]

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

make n x returns a list of length n filled with x. Throws Invalid_argument "List.make" when n < 0.

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

init n f returns a list of [f 0; f 1; ..; f (n-1)]. Throws Invalid_argument "List.init" when n < 0.

Conversions

Sourceval to_list : 'a t -> 'a list
Sourceval to_array : 'a t -> 'a array
Sourceval of_list : 'a list -> 'a t
Sourceval of_array : 'a array -> 'a t

Basics

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

Tail recursive version of List.append

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

Tail recursive version of List.(@)

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

Tail recursive version of List.concat

Sourceval flatten : 'a t t -> 'a t

Tail recursive version of List.flatten

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

replicate xs n concatenates the list xs n-times

Folding

Sourceval map : ('a -> 'b) -> 'a list -> 'b list
Sourceval mapi : (int -> 'a -> 'b) -> 'a list -> 'b list
Sourceval map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
Sourceval split : ('a * 'b) list -> 'a list * 'b list
Sourceval merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
Sourceval fold_right : ('a -> 'st -> 'st) -> 'a t -> 'st -> 'st
Sourceval fold_left1 : ('a -> 'a -> 'a) -> 'a list -> 'a

List must be non-empty. Otherwise, it raises Invalid_argment "fold_left1".

Sourceval fold_right1 : ('a -> 'a -> 'a) -> 'a list -> 'a

List must be non-empty. Otherwise, it raises Invalid_argment "fold_left1".

Sourceval concat_map : ('a -> 'b list) -> 'a list -> 'b list

concat_map f xs = concat @@ map f xs but much faster.

Sourceval rev_concat_map : ('a -> 'b list) -> 'a list -> 'b list

concat_map f xs = rev @@ concat @@ map f xs but much faster.

Sourceval map_accum_left : ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a t -> 'acc * 'b list

mapAccumL f acc t behaves like a combination of map and fold_left; it applies a function f to each element of a list t, passing an accumulating parameter acc from left to right, and returning a final value of this accumulator together with the new list.

Access

Sourceval last : 'a list -> 'a

The last element of the list. Raises Failure when the argument is . last [1;2;3] = 3

Find and assoc

Sourceval find_opt : ('a -> bool) -> 'a list -> 'a option
Sourceval find_map_opt : ('a -> 'b option) -> 'a list -> 'b option
Sourceval remove_first_match : ('a -> bool) -> 'a list -> 'a list
Sourceval assoc_all : 'a -> ('a * 'b) list -> 'b list
Sourceval assoc_opt : 'a -> ('a * 'b) list -> 'b option
Sourceval remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
Sourceval remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list

Sublist by index

Sourceval take : int -> 'a list -> 'a list
Sourceval drop : int -> 'a list -> 'a list
Sourceval sub_default : 'a list -> int -> int -> 'a list

sub_default t pos len returns a sublist of t from the position pos (0-start) and length len.

The region specified by pos and len is trimmed by t: if it exceeds the size of t, it is intersected with the region from 0 and length List.length t. One tricky example is:

sub_default [0;1;2;3;4;5] (-1) 3 = [0;1]

Sourceval take_exn : int -> 'a list -> 'a list
Sourceval drop_exn : int -> 'a list -> 'a list
Sourceval sub : 'a list -> int -> int -> 'a list
Sourceval split_at : int -> 'a list -> 'a list * 'a list

Haskell's splitAt. Always succeeds.

Sourceval splits_by : int -> 'a list -> 'a list list

Split a list into sub-lists of the fixed length

Sublist by predicate

Sourceval filter_map : ('a -> 'b option) -> 'a list -> 'b list
Sourceval rev_filter_map : ('a -> 'b option) -> 'a list -> 'b list
Sourceval span : ('a -> bool) -> 'a list -> 'a list * 'a list

span p xs extract the longest prefix of xs whose elements satisfy p.

Sourceval partition_map : ('a -> [< `Left of 'left | `Right of 'right ]) -> 'a list -> 'left list * 'right list

Sort and uniq

Sourceval uniq_dup : ('a -> 'a -> bool) -> 'a list -> 'a list * ('a * 'a) list

Filter out duplicate elements using the given equality. The first result list is the list of first unique occurrences, the second result list is the rest, the duplications removed from the first result list, paired with the corresponding element of the first result list.

O(n^2).

Sourceval uniq_dup_sorted : ('a -> 'a -> int) -> 'a list -> 'a list * ('a * 'a) list

Same as uniq_dup but only works for already sorted by the same ordering. O(n log n)

Sourceval unique : 'a list -> 'a list

Haskell's nub. O(n^2)

Sourceval unique_by : ('a -> 'a -> bool) -> 'a list -> 'a list
Sourceval has_dup : ('a -> 'a -> bool) -> 'a list -> ('a * 'a) option

Check the list is a unique list or not, wrt the equality function. If not, it returns a dupe example.

has_dup (fun x y -> fst x = fst y) [(1,2); (2,3); (4,5)] = None has_dup (fun x y -> fst x = fst y) [(1,2); (2,3); (2,5)] = Some ( (2,3), (2,5) )

O(n^2)

Sourceval group : 'a list -> 'a list list

group xs returns a list of lists such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements:

group ['M'; 'i'; 's'; 's'; 'i'; 's'; 's'; 'i'; 'p'; 'p'; 'i'] = [['M'],['i'],['s';'s'];['i'];['s';'s'];['i'];['p';'p'];['i']]

Haskell's group.

Sourceval group_by : ('a -> 'a -> bool) -> 'a list -> 'a list list

Same as group but equality can be given. Haskell's groupBy

Sourceval sort_then_group_by : ('a -> 'a -> int) -> 'a list -> 'a list list

sort then group_by

Composition

Sourceval zip : 'a list -> 'b list -> ('a * 'b) list

Haskell's zip. Like List.combine but does not raise when the lengths are not equal. Tail recursive.

With reference

Sourceval accum : 'a list ref -> 'a -> unit

accum xsref x is equivalent with xsref := x :: !xsref

Sourceval (+::=) : 'a list ref -> 'a -> unit

Same as accum

Integer ranges

Sourceval from_to : int -> int -> int list

from_to f t = [f..t]

Sourceval (--) : int -> int -> int list

Same as from_to. f--t = [f..t]

Sourceval init_from_to : int -> int -> (int -> 'a) -> 'a list

init_from_to f t fn = [fn x | x <- [f..t] ]

Misc

Sourceval intersperse : 'a -> 'a list -> 'a list
Sourceval sum : int list -> int

Modules

Sourcemodule Infix : sig ... end
Sourcemodule Stdlib : sig ... end

Non tail recursive versions

These non tail recursive versions are from stdlib.

Sourceval (@.) : 'a t -> 'a t -> 'a t

Non tail recursive version of (@)

Sourceval append_ntr : 'a t -> 'a t -> 'a t
Sourceval concat_ntr : 'a t t -> 'a t
Sourceval flatten_ntr : 'a t t -> 'a t
Sourceval map_ntr : ('a -> 'b) -> 'a t -> 'b t
Sourceval mapi_ntr : (int -> 'a -> 'b) -> 'a t -> 'b t
Sourceval fold_right_ntr : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
Sourceval map2_ntr : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
Sourceval fold_right2_ntr : ('a -> 'c -> 'b -> 'b) -> 'a list -> 'c list -> 'b -> 'b
Sourceval remove_assoc_ntr : 'a -> ('a * 'b) list -> ('a * 'b) list
Sourceval remove_assq_ntr : 'a -> ('a * 'b) list -> ('a * 'b) list
Sourceval split_ntr : ('a * 'b) list -> 'a list * 'b list
Sourceval combine_ntr : 'a list -> 'b list -> ('a * 'b) list
Sourceval merge_ntr : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list

Deprecated

Sourceval iter_until : ('a -> [ `Break of 'b | `Continue ]) -> 'a list -> 'b option
  • deprecated Use Base.loop instead.
Sourceval scani_left : (int -> 'a -> 'b -> [< `Continue of 'a | `Stop of 'a ]) -> 'a -> 'b list -> 'a
  • deprecated Use Base.loop instead.
Sourceval is_unique : ('a -> 'b) -> 'a list -> ('a * 'a) option

Check the list is a unique list or not, wrt the key function. If not, it returns a dupe example.

is_unique fst [(1,2); (2,3); (4,5)] = None is_unique fst [(1,2); (2,3); (2,5)] = Some ( (2,3), (2,5) )

  • deprecated Use has_dup
Sourceval sort_then_group : ('a -> 'a -> int) -> 'a list -> 'a list list
  • deprecated Use sort_then_group_by