lsp 1.4.1 · OCaml Package

lsp

include module type of struct include Stdlib.ListLabels end

val length : 'a list -> int

val compare_lengths : 'a list -> 'b list -> int

val compare_length_with : 'a list -> len:int -> int

val hd : 'a list -> 'a

val tl : 'a list -> 'a list

val nth_opt : 'a list -> int -> 'a option

val rev : 'a list -> 'a list

val append : 'a list -> 'a list -> 'a list

val rev_append : 'a list -> 'a list -> 'a list

val concat : 'a list list -> 'a list

val flatten : 'a list list -> 'a list

val iter : f:('a -> unit) -> 'a list -> unit

val iteri : f:(int -> 'a -> unit) -> 'a list -> unit

val map : f:('a -> 'b) -> 'a list -> 'b list

val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list

val rev_map : f:('a -> 'b) -> 'a list -> 'b list

val fold_left_map : 
  f:('acc -> 'a -> 'acc * 'b) ->
  init:'acc ->
  'a list ->
  'acc * 'b list

val fold_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a list -> 'acc

val fold_right : f:('a -> 'acc -> 'acc) -> 'a list -> init:'acc -> 'acc

val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit

val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list

val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list

val fold_left2 : 
  f:('acc -> 'a -> 'b -> 'acc) ->
  init:'acc ->
  'a list ->
  'b list ->
  'acc

val fold_right2 : 
  f:('a -> 'b -> 'acc -> 'acc) ->
  'a list ->
  'b list ->
  init:'acc ->
  'acc

val for_all : f:('a -> bool) -> 'a list -> bool

val exists : f:('a -> bool) -> 'a list -> bool

val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool

val mem : 'a -> set:'a list -> bool

val memq : 'a -> set:'a list -> bool

val find_opt : f:('a -> bool) -> 'a list -> 'a option

val find_index : f:('a -> bool) -> 'a list -> int option

val find_mapi : f:(int -> 'a -> 'b option) -> 'a list -> 'b option

val filter : f:('a -> bool) -> 'a list -> 'a list

val find_all : f:('a -> bool) -> 'a list -> 'a list

val partition : f:('a -> bool) -> 'a list -> 'a list * 'a list

val assoc_opt : 'a -> ('a * 'b) list -> 'b option

val assq : 'a -> ('a * 'b) list -> 'b

val assq_opt : 'a -> ('a * 'b) list -> 'b option

val mem_assoc : 'a -> map:('a * 'b) list -> bool

val mem_assq : 'a -> map:('a * 'b) list -> bool

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

val combine : 'a list -> 'b list -> ('a * 'b) list

val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list

val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list

val to_seq : 'a list -> 'a Stdlib.Seq.t

val of_seq : 'a Stdlib.Seq.t -> 'a list

type 'a t = 'a list

val is_empty : _ t -> bool

val is_non_empty : _ t -> bool

val filter_map : 'a t -> f:('a -> 'b option) -> 'b t

val filter_opt : 'a option t -> 'a t

val filteri : 'a t -> f:(int -> 'a -> bool) -> 'a t

val concat_map : 'a t -> f:('a -> 'b t) -> 'b t

val partition_map : 'a t -> f:('a -> ('b, 'c) Either.t) -> 'b t * 'c t

val rev_map_append : 'a t -> 'b t -> f:('a -> 'b) -> 'b t

val rev_partition_map : 'a t -> f:('a -> ('b, 'c) Either.t) -> 'b t * 'c t

type ('a, 'b) skip_or_either =

| Skip
| Left of 'a
| Right of 'b

val filter_partition_map : 
  'a t ->
  f:('a -> ('b, 'c) skip_or_either) ->
  'b t * 'c t

val rev_filter_partition_map : 
  'a t ->
  f:('a -> ('b, 'c) skip_or_either) ->
  'b t * 'c t

val find : 'a t -> f:('a -> bool) -> 'a option

val findi : 'a t -> f:('a -> bool) -> ('a * int) option

val find_exn : 'a t -> f:('a -> bool) -> 'a

val find_map : 'a t -> f:('a -> 'b option) -> 'b option

val last : 'a t -> 'a option

val destruct_last : 'a t -> ('a list * 'a) option

val sort : 'a t -> compare:('a -> 'a -> Ordering.t) -> 'a t

val stable_sort : 'a t -> compare:('a -> 'a -> Ordering.t) -> 'a t

val sort_uniq : 'a t -> compare:('a -> 'a -> Ordering.t) -> 'a t

val compare : 'a t -> 'a t -> compare:('a -> 'a -> Ordering.t) -> Ordering.t

val assoc : ('a * 'b) t -> 'a -> 'b option

val singleton : 'a -> 'a t

val nth : 'a t -> int -> 'a option

val physically_equal : 'a t -> 'a t -> bool

val init : int -> f:(int -> 'a) -> 'a list

val hd_opt : 'a t -> 'a option

val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool

val hash : ('a -> int) -> 'a list -> int

val cons : 'a -> 'a t -> 'a t

val fold_map : 'a list -> init:'b -> f:('b -> 'a -> 'b * 'c) -> 'b * 'c list

val unzip : ('a * 'b) t -> 'a t * 'b t

val for_all2 : 
  'a list ->
  'b list ->
  f:('a -> 'b -> bool) ->
  (bool, [ `Length_mismatch ]) Stdlib.result

val reduce : 'a list -> f:('a -> 'a -> 'a) -> 'a option

val min : 'a list -> f:('a -> 'a -> Ordering.t) -> 'a option

val max : 'a list -> f:('a -> 'a -> Ordering.t) -> 'a option

package lsp