Quelle cArray.mli Sprache: SML

(************************************************************************)
(*         *      The Rocq Prover / The Rocq Development Team           *)
(*  v      *         Copyright INRIA, CNRS and contributors             *)
(* <O___,, * (see version control and CREDITS file for authors & dates) *)
(*   \VV/  **************************************************************)
(*    //   *    This file is distributed under the terms of the         *)
(*         *     GNU Lesser General Public License Version 2.1          *)
(*         *     (see LICENSE file for the text of the license)         *)
(************************************************************************)

module type S = module type of Array

include S
val compare : ('a -> 'a -> int) -> 'a array -> 'a array -> int
(** First size comparison, then lexicographic order. *)

val equal : ('a -> 'a -> bool) -> 'a array -> 'a array -> bool
(** Lift equality to array type. *)

val equal_norefl : ('a -> 'a -> bool) -> 'a array -> 'a array -> bool
(** Like {!equal} but does not assume that equality is reflexive: no
    optimisation is performed if both arrays are physically the
    same. *)

val is_empty : 'a array -> bool
(** True whenever the array is empty. *)

val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool

val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool
val for_all3 : ('a -> 'b -> 'c -> bool) ->
  'a array -> 'b array -> 'c array -> bool
val for_all4 : ('a -> 'b -> 'c -> 'd -> bool) ->
  'a array -> 'b array -> 'c array -> 'd array -> bool
val for_all_i : (int -> 'a -> bool) -> int -> 'a array -> bool

val findi : (int -> 'a -> bool) -> 'a array -> int option

val find2_map : ('a -> 'b -> 'c option) -> 'a array -> 'b array -> 'c option
(** First result which is not None, or None;
    [Failure "Array.find2_map"] if the arrays don't have the same length *)

val hd : 'a array -> 'a
(** First element of an array, or [Failure "Array.hd"] if empty. *)

val tl : 'a array -> 'a array
(** Remaining part of [hd], or [Failure "Array.tl"] if empty. *)

val last : 'a array -> 'a
(** Last element of an array, or [Failure "Array.last"] if empty. *)

val cons : 'a -> 'a array -> 'a array
(** Append an element on the left. *)

val rev : 'a array -> unit
(** In place reversal. *)

val fold_right_i :
  (int -> 'b -> 'a -> 'a) -> 'b array -> 'a -> 'a
val fold_left_i : (int -> 'a -> 'b -> 'a) -> 'a -> 'b array -> 'a
val fold_right2 :
  ('a -> 'b -> 'c -> 'c) -> 'a array -> 'b array -> 'c -> 'c
val fold_right3 :
  ('a -> 'b -> 'c -> 'd -> 'd) -> 'a array -> 'b array -> 'c array -> 'd -> 'd
val fold_left2 :
  ('a -> 'b -> 'c -> 'a) -> 'a -> 'b array -> 'c array -> 'a
val fold_left3 :
  ('a -> 'b -> 'c -> 'd -> 'a) -> 'a -> 'b array -> 'c array -> 'd array -> 'a
val fold_left4 :
  ('a -> 'b -> 'c -> 'd -> 'e -> 'a) -> 'a -> 'b array -> 'c array -> 'd array -> 'e array -> 'a
val fold_left2_i :
  (int -> 'a -> 'b -> 'c -> 'a) -> 'a -> 'b array -> 'c array -> 'a
val fold_left3_i :
  (int -> 'a -> 'b -> 'c -> 'd -> 'a) -> 'a -> 'b array -> 'c array -> 'd array -> 'a
val fold_left_from : int -> ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a

val map_to_list : ('a -> 'b) -> 'a array -> 'b list
(** Composition of [map] and [to_list]. *)

val map_of_list : ('a -> 'b) -> 'a list -> 'b array
(** Composition of [map] and [of_list]. *)

val chop : int -> 'a array -> 'a array * 'a array
(** [chop i a] returns [(a1, a2)] s.t. [a = a1 + a2] and [length a1 = n].
    Raise [Failure "Array.chop"] if [i] is not a valid index. *)

val split : ('a * 'b) array -> 'a array * 'b array
val split3 : ('a * 'b * 'c) array -> 'a array * 'b array * 'c array
val split4 : ('a * 'b * 'c * 'd) array -> 'a array * 'b array * 'c array * 'd array
val transpose : 'a array array -> 'a array array

val map2_i : (int -> 'a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
val map3 :
  ('a -> 'b -> 'c -> 'd) -> 'a array -> 'b array -> 'c array -> 'd array
val map3_i :
  (int -> 'a -> 'b -> 'c -> 'd) -> 'a array -> 'b array -> 'c array -> 'd array

val map_left : ('a -> 'b) -> 'a array -> 'b array
(** As [map] but guaranteed to be left-to-right. *)

val iter2_i : (int -> 'a -> 'b -> unit) -> 'a array -> 'b array -> unit
(** Iter on two arrays. Raise [Invalid_argument "Array.iter2_i"] if sizes differ. *)

val iter3 : ('a -> 'b -> 'c -> unit) -> 'a array -> 'b array -> 'c array -> unit
(** Iter on three arrays. Raise [Invalid_argument "Array.iter3"] if sizes differ. *)

val fold_left_map : ('a -> 'b -> 'a * 'c) -> 'a -> 'b array -> 'a * 'c array
(** [fold_left_map f e_0 [|l_1...l_n|] = e_n,[|k_1...k_n|]]
    where [(e_i,k_i)=f e_{i-1} l_i]; see also [Smart.fold_left_map] *)

val fold_right_map : ('a -> 'c -> 'b * 'c) -> 'a array -> 'c -> 'b array * 'c
(** Same, folding on the right *)

val fold_left_map_i : (int -> 'a -> 'b -> 'a * 'c) -> 'a -> 'b array -> 'a * 'c array
(** Same than [fold_left_map] but passing the index of the array *)

val fold_left2_map : ('a -> 'b -> 'c -> 'a * 'd) -> 'a -> 'b array -> 'c array -> 'a * 'd array
(** Same with two arrays, folding on the left; see also [Smart.fold_left2_map] *)

val fold_left2_map_i :
  (int -> 'a -> 'b -> 'c -> 'a * 'd) -> 'a -> 'b array -> 'c array -> 'a * 'd array
(** Same than [fold_left2_map] but passing the index of the array *)

val fold_right2_map : ('a -> 'b -> 'c -> 'd * 'c) -> 'a array -> 'b array -> 'c -> 'd array * 'c
(** Same with two arrays, folding on the right *)

val distinct : 'a array -> bool
(** Return [true] if every element of the array is unique (for default
    equality). *)

val rev_of_list : 'a list -> 'a array
(** [rev_of_list l] is equivalent to [Array.of_list (List.rev l)]. *)

val rev_to_list : 'a array -> 'a list
(** [rev_to_list a] is equivalent to [List.rev (List.of_array a)]. *)

val filter_with : bool list -> 'a array -> 'a array
(** [filter_with b a] selects elements of [a] whose corresponding element in
    [b] is [true].  Raise [Invalid_argument _] when sizes differ. *)

module Smart :
sig
  val map : ('a -> 'a) -> 'a array -> 'a array
  (** [Smart.map f a] behaves as [map f a] but returns [a] instead of a copy when
      [f x == x] for all [x] in [a]. *)

  val map_i : (int -> 'a -> 'a) -> 'a array -> 'a array

  val map2 : ('a -> 'b -> 'b) -> 'a array -> 'b array -> 'b array
  (** [Smart.map2 f a b] behaves as [map2 f a b] but returns [a] instead of a copy when
      [f x y == y] for all [x] in [a] and [y] in [b] pointwise. *)

  val fold_left_map : ('a -> 'b -> 'a * 'b) -> 'a -> 'b array -> 'a * 'b array
  (** [Smart.fold_left_map f a b] behaves as [fold_left_map] but
      returns [b] as second component instead of a copy of [b] when
      the output array is pointwise the same as the input array [b] *)

  val fold_left_map_i : (int -> 'a -> 'b -> 'a * 'b) -> 'a -> 'b array -> 'a * 'b array
  (** [Smart.fold_left_map_i f a b] behaves as [fold_left_map_i] but
      returns [b] as second component instead of a copy of [b] when
      the output array is pointwise the same as the input array [b] *)

  val fold_left2_map : ('a -> 'b -> 'c -> 'a * 'c) -> 'a -> 'b array -> 'c array -> 'a * 'c array
  (** [Smart.fold_left2_map f a b c] behaves as [fold_left2_map] but
      returns [c] as second component instead of a copy of [c] when
      the output array is pointwise the same as the input array [c] *)

end
(** The functions defined in this module are optimized specializations
    of the main ones, when the returned array is of same type as one of
    the original array. *)

module Fun1 :
sig
  val map : ('r -> 'a -> 'b) -> 'r -> 'a array -> 'b array
  (** [Fun1.map f x v = map (f x) v] *)

  val iter : ('r -> 'a -> unit) -> 'r -> 'a array -> unit
  (** [Fun1.iter f x v = iter (f x) v] *)

  val iter2 : ('r -> 'a -> 'b -> unit) -> 'r -> 'a array -> 'b array -> unit
  (** [Fun1.iter2 f x v1 v2 = iter (f x) v1 v2] *)

  module Smart :
  sig
    val map : ('r -> 'a -> 'a) -> 'r -> 'a array -> 'a array
    (** [Fun1.Smart.map f x v = Smart.map (f x) v] *)
  end

end
(** The functions defined in this module are the same as the main ones, except
    that they are all higher-order, and their function arguments have an
    additional parameter. This allows us to prevent closure creation in critical
    cases. *)

quality98%

¤ Dauer der Verarbeitung: 0.37 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.