@tellahq/rescript 10.1.0-alpha.2 → 10.1.4-republish-2

package/lib/ocaml/array.mli

@@ -1,275 +0,0 @@
-(**************************************************************************)
-(*                                                                        *)
-(*                                 OCaml                                  *)
-(*                                                                        *)
-(*             Xavier Leroy, projet Cristal, INRIA Rocquencourt           *)
-(*                                                                        *)
-(*   Copyright 1996 Institut National de Recherche en Informatique et     *)
-(*     en Automatique.                                                    *)
-(*                                                                        *)
-(*   All rights reserved.  This file is distributed under the terms of    *)
-(*   the GNU Lesser General Public License version 2.1, with the          *)
-(*   special exception on linking described in the file LICENSE.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-(** Array operations. *)
-
-external length : 'a array -> int = "%array_length"
-(** Return the length (number of elements) of the given array. *)
-
-external get : 'a array -> int -> 'a = "%array_safe_get"
-(** [Array.get a n] returns the element number [n] of array [a].
-   The first element has number 0.
-   The last element has number [Array.length a - 1].
-   You can also write [a.(n)] instead of [Array.get a n].
-
-   Raise [Invalid_argument "index out of bounds"]
-   if [n] is outside the range 0 to [(Array.length a - 1)]. *)
-
-external set : 'a array -> int -> 'a -> unit = "%array_safe_set"
-(** [Array.set a n x] modifies array [a] in place, replacing
-   element number [n] with [x].
-   You can also write [a.(n) <- x] instead of [Array.set a n x].
-
-   Raise [Invalid_argument "index out of bounds"]
-   if [n] is outside the range 0 to [Array.length a - 1]. *)
-
-external make : int -> 'a -> 'a array = "?make_vect"
-(** [Array.make n x] returns a fresh array of length [n],
-   initialized with [x].
-   All the elements of this new array are initially
-   physically equal to [x] (in the sense of the [==] predicate).
-   Consequently, if [x] is mutable, it is shared among all elements
-   of the array, and modifying [x] through one of the array entries
-   will modify all other entries at the same time.
-
-   Raise [Invalid_argument] if [n < 0] or [n > Sys.max_array_length].
-   If the value of [x] is a floating-point number, then the maximum
-   size is only [Sys.max_array_length / 2].*)
-
-external create : int -> 'a -> 'a array = "?make_vect"
-  [@@ocaml.deprecated "Use Array.make instead."]
-(** @deprecated [Array.create] is an alias for {!Array.make}. *)
-
-external create_float: int -> float array = "?make_float_vect"
-(** [Array.create_float n] returns a fresh float array of length [n],
-    with uninitialized data.
-    @since 4.03 *)
-
-val make_float: int -> float array
-  [@@ocaml.deprecated "Use Array.create_float instead."]
-(** @deprecated [Array.make_float] is an alias for {!Array.create_float}. *)
-
-val init : int -> (int -> 'a) -> 'a array
-(** [Array.init n f] returns a fresh array of length [n],
-   with element number [i] initialized to the result of [f i].
-   In other terms, [Array.init n f] tabulates the results of [f]
-   applied to the integers [0] to [n-1].
-
-   Raise [Invalid_argument] if [n < 0] or [n > Sys.max_array_length].
-   If the return type of [f] is [float], then the maximum
-   size is only [Sys.max_array_length / 2].*)
-
-val make_matrix : int -> int -> 'a -> 'a array array
-(** [Array.make_matrix dimx dimy e] returns a two-dimensional array
-   (an array of arrays) with first dimension [dimx] and
-   second dimension [dimy]. All the elements of this new matrix
-   are initially physically equal to [e].
-   The element ([x,y]) of a matrix [m] is accessed
-   with the notation [m.(x).(y)].
-
-   Raise [Invalid_argument] if [dimx] or [dimy] is negative or
-   greater than {!Sys.max_array_length}.
-   If the value of [e] is a floating-point number, then the maximum
-   size is only [Sys.max_array_length / 2]. *)
-
-val create_matrix : int -> int -> 'a -> 'a array array
-  [@@ocaml.deprecated "Use Array.make_matrix instead."]
-(** @deprecated [Array.create_matrix] is an alias for {!Array.make_matrix}. *)
-
-val append : 'a array -> 'a array -> 'a array
-(** [Array.append v1 v2] returns a fresh array containing the
-   concatenation of the arrays [v1] and [v2]. *)
-
-val concat : 'a array list -> 'a array
-(** Same as {!Array.append}, but concatenates a list of arrays. *)
-
-val sub : 'a array -> int -> int -> 'a array
-(** [Array.sub a start len] returns a fresh array of length [len],
-   containing the elements number [start] to [start + len - 1]
-   of array [a].
-
-   Raise [Invalid_argument "Array.sub"] if [start] and [len] do not
-   designate a valid subarray of [a]; that is, if
-   [start < 0], or [len < 0], or [start + len > Array.length a]. *)
-
-val copy : 'a array -> 'a array
-(** [Array.copy a] returns a copy of [a], that is, a fresh array
-   containing the same elements as [a]. *)
-
-val fill : 'a array -> int -> int -> 'a -> unit
-(** [Array.fill a ofs len x] modifies the array [a] in place,
-   storing [x] in elements number [ofs] to [ofs + len - 1].
-
-   Raise [Invalid_argument "Array.fill"] if [ofs] and [len] do not
-   designate a valid subarray of [a]. *)
-
-val blit : 'a array -> int -> 'a array -> int -> int -> unit
-(** [Array.blit v1 o1 v2 o2 len] copies [len] elements
-   from array [v1], starting at element number [o1], to array [v2],
-   starting at element number [o2]. It works correctly even if
-   [v1] and [v2] are the same array, and the source and
-   destination chunks overlap.
-
-   Raise [Invalid_argument "Array.blit"] if [o1] and [len] do not
-   designate a valid subarray of [v1], or if [o2] and [len] do not
-   designate a valid subarray of [v2]. *)
-
-val to_list : 'a array -> 'a list
-(** [Array.to_list a] returns the list of all the elements of [a]. *)
-
-val of_list : 'a list -> 'a array
-(** [Array.of_list l] returns a fresh array containing the elements
-   of [l]. *)
-
-
-(** {1 Iterators} *)
-
-
-val iter : ('a -> unit) -> 'a array -> unit
-(** [Array.iter f a] applies function [f] in turn to all
-   the elements of [a].  It is equivalent to
-   [f a.(0); f a.(1); ...; f a.(Array.length a - 1); ()]. *)
-
-val iteri : (int -> 'a -> unit) -> 'a array -> unit
-(** Same as {!Array.iter}, but the
-   function is applied with the index of the element as first argument,
-   and the element itself as second argument. *)
-
-val map : ('a -> 'b) -> 'a array -> 'b array
-(** [Array.map f a] applies function [f] to all the elements of [a],
-   and builds an array with the results returned by [f]:
-   [[| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |]]. *)
-
-val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array
-(** Same as {!Array.map}, but the
-   function is applied to the index of the element as first argument,
-   and the element itself as second argument. *)
-
-val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a
-(** [Array.fold_left f x a] computes
-   [f (... (f (f x a.(0)) a.(1)) ...) a.(n-1)],
-   where [n] is the length of the array [a]. *)
-
-val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a
-(** [Array.fold_right f a x] computes
-   [f a.(0) (f a.(1) ( ... (f a.(n-1) x) ...))],
-   where [n] is the length of the array [a]. *)
-
-
-(** {1 Iterators on two arrays} *)
-
-
-val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit
-(** [Array.iter2 f a b] applies function [f] to all the elements of [a]
-   and [b].
-   Raise [Invalid_argument] if the arrays are not the same size.
-   @since 4.03.0 *)
-
-val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
-(** [Array.map2 f a b] applies function [f] to all the elements of [a]
-   and [b], and builds an array with the results returned by [f]:
-   [[| f a.(0) b.(0); ...; f a.(Array.length a - 1) b.(Array.length b - 1)|]].
-   Raise [Invalid_argument] if the arrays are not the same size.
-   @since 4.03.0 *)
-
-
-(** {1 Array scanning} *)
-
-
-val for_all : ('a -> bool) -> 'a array -> bool
-(** [Array.for_all p [|a1; ...; an|]] checks if all elements of the array
-   satisfy the predicate [p]. That is, it returns
-   [(p a1) && (p a2) && ... && (p an)].
-   @since 4.03.0 *)
-
-val exists : ('a -> bool) -> 'a array -> bool
-(** [Array.exists p [|a1; ...; an|]] checks if at least one element of
-    the array satisfies the predicate [p]. That is, it returns
-    [(p a1) || (p a2) || ... || (p an)].
-    @since 4.03.0 *)
-
-val mem : 'a -> 'a array -> bool
-(** [mem a l] is true if and only if [a] is equal
-   to an element of [l].
-   @since 4.03.0 *)
-
-val memq : 'a -> 'a array -> bool
-(** Same as {!Array.mem}, but uses physical equality instead of structural
-   equality to compare array elements.
-   @since 4.03.0 *)
-
-
-(** {1 Sorting} *)
-
-
-val sort : ('a -> 'a -> int) -> 'a array -> unit
-(** Sort an array in increasing order according to a comparison
-   function.  The comparison function must return 0 if its arguments
-   compare as equal, a positive integer if the first is greater,
-   and a negative integer if the first is smaller (see below for a
-   complete specification).  For example, {!Pervasives.compare} is
-   a suitable comparison function, provided there are no floating-point
-   NaN values in the data.  After calling [Array.sort], the
-   array is sorted in place in increasing order.
-   [Array.sort] is guaranteed to run in constant heap space
-   and (at most) logarithmic stack space.
-
-   The current implementation uses Heap Sort.  It runs in constant
-   stack space.
-
-   Specification of the comparison function:
-   Let [a] be the array and [cmp] the comparison function.  The following
-   must be true for all x, y, z in a :
--   [cmp x y] > 0 if and only if [cmp y x] < 0
--   if [cmp x y] >= 0 and [cmp y z] >= 0 then [cmp x z] >= 0
-
-   When [Array.sort] returns, [a] contains the same elements as before,
-   reordered in such a way that for all i and j valid indices of [a] :
--   [cmp a.(i) a.(j)] >= 0 if and only if i >= j
-*)
-
-val stable_sort : ('a -> 'a -> int) -> 'a array -> unit
-(** Same as {!Array.sort}, but the sorting algorithm is stable (i.e.
-   elements that compare equal are kept in their original order) and
-   not guaranteed to run in constant heap space.
-
-   The current implementation uses Merge Sort. It uses [n/2]
-   words of heap space, where [n] is the length of the array.
-   It is usually faster than the current implementation of {!Array.sort}.
-*)
-
-val fast_sort : ('a -> 'a -> int) -> 'a array -> unit
-(** Same as {!Array.sort} or {!Array.stable_sort}, whichever is faster
-    on typical input.
-*)
-
-
-(**/**)
-(** {1 Undocumented functions} *)
-
-(* The following is for system use only. Do not call directly. *)
-
-external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get"
-external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set"
-
-module Floatarray : sig
-  external create : int -> floatarray = "?floatarray_create"
-  external length : floatarray -> int = "%floatarray_length"
-  external get : floatarray -> int -> float = "%floatarray_safe_get"
-  external set : floatarray -> int -> float -> unit = "%floatarray_safe_set"
-  external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get"
-  external unsafe_set : floatarray -> int -> float -> unit
-      = "%floatarray_unsafe_set"
-end

package/lib/ocaml/arrayLabels.ml

@@ -1,307 +0,0 @@
-(**************************************************************************)
-(*                                                                        *)
-(*                                 OCaml                                  *)
-(*                                                                        *)
-(*             Xavier Leroy, projet Cristal, INRIA Rocquencourt           *)
-(*                                                                        *)
-(*   Copyright 1996 Institut National de Recherche en Informatique et     *)
-(*     en Automatique.                                                    *)
-(*                                                                        *)
-(*   All rights reserved.  This file is distributed under the terms of    *)
-(*   the GNU Lesser General Public License version 2.1, with the          *)
-(*   special exception on linking described in the file LICENSE.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-(* Array operations *)
-
-external length : 'a array -> int = "%array_length"
-external get: 'a array -> int -> 'a = "%array_safe_get"
-external set: 'a array -> int -> 'a -> unit = "%array_safe_set"
-external unsafe_get: 'a array -> int -> 'a = "%array_unsafe_get"
-external unsafe_set: 'a array -> int -> 'a -> unit = "%array_unsafe_set"
-external make: int -> 'a -> 'a array = "?make_vect"
-external create: int -> 'a -> 'a array = "?make_vect"
-external unsafe_sub : 'a array -> int -> int -> 'a array = "?array_sub"
-
-external append_prim : 'a array -> 'a array -> 'a array = "concat"
-[@@send]
-
-external concat : 'a array list -> 'a array = "?array_concat"
-external unsafe_blit :
-  'a array -> int -> 'a array -> int -> int -> unit = "?array_blit"
-external create_float: int -> float array = "?make_float_vect"
-let make_float = create_float
-
-module Floatarray = struct
-  external create : int -> floatarray = "?floatarray_create"
-  external length : floatarray -> int = "%floatarray_length"
-  external get : floatarray -> int -> float = "%floatarray_safe_get"
-  external set : floatarray -> int -> float -> unit = "%floatarray_safe_set"
-  external unsafe_get : floatarray -> int -> float = "%floatarray_unsafe_get"
-  external unsafe_set : floatarray -> int -> float -> unit
-      = "%floatarray_unsafe_set"
-end
-
-let init l ~f =
-  if l = 0 then [||] else
-  if l < 0 then invalid_arg "Array.init"
-  (* See #6575. We could also check for maximum array size, but this depends
-     on whether we create a float array or a regular one... *)
-  else
-   let res = create l (f 0) in
-   for i = 1 to pred l do
-     unsafe_set res i (f i)
-   done;
-   res
-
-let make_matrix ~dimx:sx ~dimy:sy init =
-  let res = create sx [||] in
-  for x = 0 to pred sx do
-    unsafe_set res x (create sy init)
-  done;
-  res
-
-let create_matrix = make_matrix
-
-let copy a =
-  let l = length a in if l = 0 then [||] else unsafe_sub a 0 l
-
-let append a1 a2 =
-  let l1 = length a1 in
-  if l1 = 0 then copy a2
-  else if length a2 = 0 then unsafe_sub a1 0 l1
-  else append_prim a1 a2
-
-let sub a ~pos:ofs ~len =
-  if ofs < 0 || len < 0 || ofs > length a - len
-  then invalid_arg "Array.sub"
-  else unsafe_sub a ofs len
-
-let fill a ~pos:ofs ~len v =
-  if ofs < 0 || len < 0 || ofs > length a - len
-  then invalid_arg "Array.fill"
-  else for i = ofs to ofs + len - 1 do unsafe_set a i v done
-
-let blit ~src:a1 ~src_pos:ofs1 ~dst:a2 ~dst_pos:ofs2 ~len =
-  if len < 0 || ofs1 < 0 || ofs1 > length a1 - len
-             || ofs2 < 0 || ofs2 > length a2 - len
-  then invalid_arg "Array.blit"
-  else unsafe_blit a1 ofs1 a2 ofs2 len
-
-let iter ~f a =
-  for i = 0 to length a - 1 do f(unsafe_get a i) done
-
-let iter2 ~f a b =
-  if length a <> length b then
-    invalid_arg "Array.iter2: arrays must have the same length"
-  else
-    for i = 0 to length a - 1 do f (unsafe_get a i) (unsafe_get b i) done
-
-let map ~f a =
-  let l = length a in
-  if l = 0 then [||] else begin
-    let r = create l (f(unsafe_get a 0)) in
-    for i = 1 to l - 1 do
-      unsafe_set r i (f(unsafe_get a i))
-    done;
-    r
-  end
-
-let map2 ~f a b =
-  let la = length a in
-  let lb = length b in
-  if la <> lb then
-    invalid_arg "Array.map2: arrays must have the same length"
-  else begin
-    if la = 0 then [||] else begin
-      let r = create la (f (unsafe_get a 0) (unsafe_get b 0)) in
-      for i = 1 to la - 1 do
-        unsafe_set r i (f (unsafe_get a i) (unsafe_get b i))
-      done;
-      r
-    end
-  end
-
-let iteri ~f a =
-  for i = 0 to length a - 1 do f i (unsafe_get a i) done
-
-let mapi ~f a =
-  let l = length a in
-  if l = 0 then [||] else begin
-    let r = create l (f 0 (unsafe_get a 0)) in
-    for i = 1 to l - 1 do
-      unsafe_set r i (f i (unsafe_get a i))
-    done;
-    r
-  end
-
-let to_list a =
-  let rec tolist i res =
-    if i < 0 then res else tolist (i - 1) (unsafe_get a i :: res) in
-  tolist (length a - 1) []
-
-(* Cannot use List.length here because the List module depends on Array. *)
-let rec list_length accu = function
-  | [] -> accu
-  | _::t -> list_length (succ accu) t
-
-let of_list = function
-    [] -> [||]
-  | hd::tl as l ->
-      let a = create (list_length 0 l) hd in
-      let rec fill i = function
-          [] -> a
-        | hd::tl -> unsafe_set a i hd; fill (i+1) tl in
-      fill 1 tl
-
-let fold_left ~f ~init:x a =
-  let r = ref x in
-  for i = 0 to length a - 1 do
-    r := f !r (unsafe_get a i)
-  done;
-  !r
-
-let fold_right ~f a ~init:x =
-  let r = ref x in
-  for i = length a - 1 downto 0 do
-    r := f (unsafe_get a i) !r
-  done;
-  !r
-
-let exists ~f:p a =
-  let n = length a in
-  let rec loop i =
-    if i = n then false
-    else if p (unsafe_get a i) then true
-    else loop (succ i) in
-  loop 0
-
-let for_all ~f:p a =
-  let n = length a in
-  let rec loop i =
-    if i = n then true
-    else if p (unsafe_get a i) then loop (succ i)
-    else false in
-  loop 0
-
-let mem x ~set:a =
-  let n = length a in
-  let rec loop i =
-    if i = n then false
-    else if compare (unsafe_get a i) x = 0 then true
-    else loop (succ i) in
-  loop 0
-
-let memq x ~set:a =
-  let n = length a in
-  let rec loop i =
-    if i = n then false
-    else if x == (unsafe_get a i) then true
-    else loop (succ i) in
-  loop 0
-
-exception Bottom of int
-let sort ~cmp a =
-  let maxson l i =
-    let i31 = i+i+i+1 in
-    let x = ref i31 in
-    if i31+2 < l then begin
-      if cmp (get a i31) (get a (i31+1)) < 0 then x := i31+1;
-      if cmp (get a !x) (get a (i31+2)) < 0 then x := i31+2;
-      !x
-    end else
-      if i31+1 < l && cmp (get a i31) (get a (i31+1)) < 0
-      then i31+1
-      else if i31 < l then i31 else raise (Bottom i)
-  in
-  let rec trickledown l i e =
-    let j = maxson l i in
-    if cmp (get a j) e > 0 then begin
-      set a i (get a j);
-      trickledown l j e;
-    end else begin
-      set a i e;
-    end;
-  in
-  let trickle l i e = try trickledown l i e with Bottom i -> set a i e in
-  let rec bubbledown l i =
-    let j = maxson l i in
-    set a i (get a j);
-    bubbledown l j
-  in
-  let bubble l i = try bubbledown l i with Bottom i -> i in
-  let rec trickleup i e =
-    let father = (i - 1) / 3 in
-    assert (i <> father);
-    if cmp (get a father) e < 0 then begin
-      set a i (get a father);
-      if father > 0 then trickleup father e else set a 0 e;
-    end else begin
-      set a i e;
-    end;
-  in
-  let l = length a in
-  for i = (l + 1) / 3 - 1 downto 0 do trickle l i (get a i); done;
-  for i = l - 1 downto 2 do
-    let e = (get a i) in
-    set a i (get a 0);
-    trickleup (bubble i 0) e;
-  done;
-  if l > 1 then (let e = (get a 1) in set a 1 (get a 0); set a 0 e)
-
-
-let cutoff = 5
-let stable_sort ~cmp a =
-  let merge src1ofs src1len src2 src2ofs src2len dst dstofs =
-    let src1r = src1ofs + src1len and src2r = src2ofs + src2len in
-    let rec loop i1 s1 i2 s2 d =
-      if cmp s1 s2 <= 0 then begin
-        set dst d s1;
-        let i1 = i1 + 1 in
-        if i1 < src1r then
-          loop i1 (get a i1) i2 s2 (d + 1)
-        else
-          blit ~src:src2 ~src_pos:i2 ~dst ~dst_pos:(d + 1) ~len:(src2r - i2)
-      end else begin
-        set dst d s2;
-        let i2 = i2 + 1 in
-        if i2 < src2r then
-          loop i1 s1 i2 (get src2 i2) (d + 1)
-        else
-          blit ~src:a ~src_pos:i1 ~dst ~dst_pos:(d + 1) ~len:(src1r - i1)
-      end
-    in loop src1ofs (get a src1ofs) src2ofs (get src2 src2ofs) dstofs;
-  in
-  let isortto srcofs dst dstofs len =
-    for i = 0 to len - 1 do
-      let e = (get a (srcofs + i)) in
-      let j = ref (dstofs + i - 1) in
-      while (!j >= dstofs && cmp (get dst !j) e > 0) do
-        set dst (!j + 1) (get dst !j);
-        decr j;
-      done;
-      set dst (!j + 1) e;
-    done;
-  in
-  let rec sortto srcofs dst dstofs len =
-    if len <= cutoff then isortto srcofs dst dstofs len else begin
-      let l1 = len / 2 in
-      let l2 = len - l1 in
-      sortto (srcofs + l1) dst (dstofs + l1) l2;
-      sortto srcofs a (srcofs + l2) l1;
-      merge (srcofs + l2) l1 dst (dstofs + l1) l2 dst dstofs;
-    end;
-  in
-  let l = length a in
-  if l <= cutoff then isortto 0 a 0 l else begin
-    let l1 = l / 2 in
-    let l2 = l - l1 in
-    let t = make l2 (get a 0) in
-    sortto l1 t 0 l2;
-    sortto 0 a l2 l1;
-    merge l2 l1 t 0 l2 a 0;
-  end
-
-
-let fast_sort = stable_sort