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

package/lib/ocaml/sort.cppo.ml

@@ -1,267 +0,0 @@
-#ifdef TYPE_INT
-type element = int 
-#elif defined TYPE_STRING
-type element = string
-#else
-  [%error "unknown type"]
-#endif  
-
-module A = Belt_Array 
-
-let rec sortedLengthAuxMore (xs : element array) prec acc len = 
-  if acc >= len then acc 
-  else 
-    let v = A.getUnsafe xs acc in 
-    if prec > v then 
-      sortedLengthAuxMore xs v (acc + 1) len 
-    else acc   
-
-let rec sortedLengthAuxLess (xs : element array) prec acc len = 
-  if acc >= len then acc 
-  else 
-    let v = A.getUnsafe xs acc in 
-    if prec < v then 
-      sortedLengthAuxLess xs v (acc + 1) len
-    else acc   
-    
-let strictlySortedLength (xs : element array) = 
-  let len = A.length xs in 
-  match len with 
-  | 0 | 1 -> len 
-  | _ -> 
-    let x0, x1 = A.getUnsafe xs 0, A.getUnsafe xs 1 in 
-    (* let c = cmp x0 x1 [@bs]  in *)
-    if x0 < x1 then 
-      sortedLengthAuxLess xs x1 2 len
-    else if x0 > x1 then 
-      - (sortedLengthAuxMore xs x1 2 len)
-    else 1  
-
-let rec isSortedAux (a : element array) i  last_bound = 
-  (* when `i = len - 1`, it reaches the last element*)
-  if i = last_bound then true 
-  else 
-  if A.getUnsafe a i <= A.getUnsafe a (i+1)  then 
-    isSortedAux a (i + 1)  last_bound 
-  else false 
-
-
-let isSorted a =
-  let len = A.length a in 
-  if len = 0 then true
-  else isSortedAux a 0  (len - 1)
-
-
-let cutoff = 5
-
-let merge (src : element array) 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  s1 <= s2  then begin
-      A.setUnsafe dst d s1;
-      let i1 = i1 + 1 in
-      if i1 < src1r then
-        loop i1 (A.getUnsafe src i1) i2 s2 (d + 1)
-      else
-        A.blitUnsafe ~src:src2 ~srcOffset:i2 ~dst ~dstOffset:(d + 1) ~len:(src2r - i2)
-    end else begin
-      A.setUnsafe dst d s2;
-      let i2 = i2 + 1 in
-      if i2 < src2r then
-        loop i1 s1 i2 (A.getUnsafe src2 i2) (d + 1)
-      else
-        A.blitUnsafe ~src ~srcOffset:i1 ~dst ~dstOffset:(d + 1) ~len:(src1r - i1)
-    end
-  in 
-  loop src1ofs (A.getUnsafe src src1ofs) src2ofs (A.getUnsafe src2 src2ofs) dstofs
-  
-
-
-let union (src : element array) src1ofs src1len src2 src2ofs src2len dst dstofs  =
-  let src1r = src1ofs + src1len in 
-  let src2r = src2ofs + src2len in
-  let rec loop i1 s1 i2 s2 d =
-    (* let c = cmp s1 s2 [@bs] in  *)
-    if s1 < s2 then begin
-      (* `s1` is larger than all elements in `d` *)
-      A.setUnsafe dst d s1; 
-      let i1 = i1 + 1 in
-      let d = d + 1 in 
-      if i1 < src1r then
-        loop i1 (A.getUnsafe src i1) i2 s2 d
-      else
-        begin 
-          A.blitUnsafe ~src:src2 ~srcOffset:i2 ~dst ~dstOffset:d ~len:(src2r - i2);
-          d + src2r - i2   
-        end
-    end 
-    else if s1 = s2 then begin 
-      A.setUnsafe dst d s1;
-      let i1 = i1 + 1 in
-      let i2 = i2 + 1 in 
-      let d  = d + 1 in 
-      if i1 < src1r && i2 < src2r then 
-        loop i1 (A.getUnsafe src i1) i2 (A.getUnsafe src2 i2) d
-      else if i1 = src1r then   
-        (A.blitUnsafe ~src:src2 ~srcOffset:i2 ~dst ~dstOffset:d ~len:(src2r - i2);
-         d + src2r - i2)
-      else    
-        (A.blitUnsafe ~src ~srcOffset:i1 ~dst ~dstOffset:d ~len:(src1r - i1);
-         d + src1r - i1)
-    end 
-    else begin
-      A.setUnsafe dst d s2;
-      let i2 = i2 + 1 in
-      let d = d + 1 in 
-      if i2 < src2r then
-        loop i1 s1 i2 (A.getUnsafe src2 i2) d
-      else
-        (A.blitUnsafe ~src ~srcOffset:i1 ~dst ~dstOffset:d ~len:(src1r - i1);
-         d + src1r - i1
-        )
-    end
-  in 
-  loop src1ofs 
-    (A.getUnsafe src src1ofs) 
-    src2ofs 
-    (A.getUnsafe src2 src2ofs) dstofs
-  
-let intersect (src : element array) src1ofs src1len src2 src2ofs src2len dst dstofs  =
-  let src1r = src1ofs + src1len in 
-  let src2r = src2ofs + src2len in
-  let rec loop i1 s1 i2 s2 d =
-    (* let c = cmp s1 s2 [@bs] in  *)
-    if s1 < s2 then begin
-      (* A.setUnsafe dst d s1; *)
-      let i1 = i1 + 1 in
-      if i1 < src1r then
-        loop i1 (A.getUnsafe src i1) i2 s2 d
-      else
-        d
-    end 
-    else if s1 = s2 then begin 
-      A.setUnsafe dst d s1;
-      let i1 = i1 + 1 in
-      let i2 = i2 + 1 in 
-      let d = d + 1 in 
-      if i1 < src1r && i2 < src2r then 
-        loop i1 (A.getUnsafe src i1) i2 (A.getUnsafe src2 i2) d
-      else d
-    end 
-    else begin
-      (* A.setUnsafe dst d s2; *)
-      let i2 = i2 + 1 in
-      if i2 < src2r then
-        loop i1 s1 i2 (A.getUnsafe src2 i2) d
-      else
-        d
-    end
-  in 
-  loop src1ofs 
-    (A.getUnsafe src src1ofs) 
-    src2ofs 
-    (A.getUnsafe src2 src2ofs) dstofs    
-
-let diff (src : element array) src1ofs src1len src2 src2ofs src2len dst dstofs  =
-  let src1r = src1ofs + src1len in 
-  let src2r = src2ofs + src2len in
-  let rec loop i1 s1 i2 s2 d =
-    (* let c = cmp s1 s2 [@bs] in  *)
-    if s1 < s2 then begin
-      A.setUnsafe dst d s1;
-      let d = d + 1 in 
-      let i1 = i1 + 1 in      
-      if i1 < src1r then
-        loop i1 (A.getUnsafe src i1) i2 s2 d
-      else
-        d
-    end 
-    else if s1 = s2 then begin 
-      let i1 = i1 + 1 in
-      let i2 = i2 + 1 in 
-      if i1 < src1r && i2 < src2r then 
-        loop i1 (A.getUnsafe src i1) i2 (A.getUnsafe src2 i2) d
-      else if i1 = src1r then 
-        d
-      else 
-      (A.blitUnsafe ~src ~srcOffset:i1 ~dst ~dstOffset:d ~len:(src1r - i1);
-        d + src1r - i1)
-    end 
-    else begin
-      let i2 = i2 + 1 in
-      if i2 < src2r then
-        loop i1 s1 i2 (A.getUnsafe src2 i2) d
-      else
-        (A.blitUnsafe ~src ~srcOffset:i1 ~dst ~dstOffset:d ~len:(src1r - i1);
-        d + src1r - i1)        
-    end
-  in 
-  loop src1ofs 
-    (A.getUnsafe src src1ofs) 
-    src2ofs 
-    (A.getUnsafe src2 src2ofs) dstofs        
-
-let insertionSort (src : element array) srcofs dst dstofs len  =
-  for i = 0 to len - 1 do
-    let e = (A.getUnsafe src (srcofs + i)) in
-    let j = ref (dstofs + i - 1) in
-    while j.contents >= dstofs &&  A.getUnsafe dst j.contents > e   do
-      A.setUnsafe dst (j.contents + 1) (A.getUnsafe dst j.contents);
-      j.contents <- j.contents - 1;
-    done;
-    A.setUnsafe dst (j.contents + 1) e;
-  done    
-
-let rec sortTo (src : element array) srcofs dst dstofs len  =
-  if len <= cutoff then insertionSort src srcofs dst dstofs len  
-  else begin
-    let l1 = len / 2 in
-    let l2 = len - l1 in
-    sortTo src (srcofs + l1) dst (dstofs + l1) l2 ;
-    sortTo src srcofs src (srcofs + l2) l1 ;
-    merge src (srcofs + l2) l1 dst (dstofs + l1) l2 dst dstofs ;
-  end    
-
-let stableSortInPlace  (a : element array)  =
-  let l = A.length a in
-  if l <= cutoff then insertionSort a 0 a 0 l  
-  else begin
-    let l1 = l / 2 in
-    let l2 = l - l1 in
-    let t = Belt_Array.makeUninitializedUnsafe l2 in 
-    sortTo a l1 t 0 l2 ;
-    sortTo a 0 a l2 l1 ;
-    merge a l2 l1 t 0 l2 a 0 ;
-  end
-
-let stableSort a = let b = A.copy a  in stableSortInPlace b; b 
-
-let rec binarySearchAux (arr : element array) lo hi key =   
-
-    let mid = (lo + hi)/2 in 
-    let midVal = A.getUnsafe arr mid in 
-    (* let c = cmp key midVal [@bs] in  *)
-    if key = midVal then mid 
-    else if key < midVal then  (*  a[lo] =< key < a[mid] <= a[hi] *)
-      if hi = mid then  
-        if  (A.getUnsafe arr lo) = key  then lo
-        else - (hi + 1)
-      else binarySearchAux arr lo mid key 
-    else  (*  a[lo] =< a[mid] < key <= a[hi] *)
-      if lo = mid then 
-        if (A.getUnsafe arr hi) = key  then hi
-        else - (hi + 1)
-      else binarySearchAux arr mid hi key 
-
-let binarySearch (sorted : element array) key  : int =  
-  let len = A.length sorted in 
-  if len = 0 then -1 
-  else 
-    let lo = A.getUnsafe sorted 0 in 
-    (* let c = cmp key lo [@bs] in  *)
-    if key < lo then -1 
-    else
-    let hi = A.getUnsafe sorted (len - 1) in 
-    (* let c2 = cmp key hi [@bs]in  *)
-    if key > hi then - (len + 1)
-    else binarySearchAux sorted 0 (len - 1) key 

package/lib/ocaml/sort.cppo.mli

@@ -1,96 +0,0 @@
-
-(* Copyright (C) 2017 Authors of ReScript
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * In addition to the permissions granted to you by the LGPL, you may combine
- * or link a "work that uses the Library" with a publicly distributed version
- * of this file to produce a combined library or application, then distribute
- * that combined work under the terms of your choosing, with no requirement
- * to comply with the obligations normally placed on you by section 4 of the
- * LGPL version 3 (or the corresponding section of a later version of the LGPL
- * should you choose to use a later version).
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
-
-
-(** This is a specialized module for [`Belt_SortArray`](), the docs in that module also
-    applies here, except the comparator is fixed and inlined
-*)
-
-#ifdef TYPE_INT
-type element = int
-#elif defined TYPE_STRING
-type element = string
-#else
-[%error "unknown type"]
-#endif
-
-val strictlySortedLength: element array -> int
-(**
-  The same as [`Belt_SortArray.strictlySortedLength`]() except the comparator is fixed
-
-  **return** `+n` means increasing order  `-n` means negative order
-*)
-
-
-val isSorted: element array  -> bool
-(** `sorted xs` return true if `xs` is in non strict increasing order *)
-
-val stableSortInPlace: element array -> unit
-(**
-  The same as [`Belt_SortArray.stableSortInPlaceBy`]() except the comparator is fixed
-*)
-
-val stableSort: element array -> element array
-(** The same as [`Belt_SortArray.stableSortBy`]() except the comparator is fixed *)
-
-val binarySearch: element array -> element -> int
-(**
-  If value is not found and value is less than one or more elements in array,
-  the negative number returned is the bitwise complement of the index of the first element
-  that is larger than value.
-
-  If value is not found and value is greater than all elements in array,
-  the negative number returned is the bitwise complement of
-  (the index of the last element plus 1)
-
-  for example, if `key` is smaller than all elements return `-1` since `lnot (-1) = 0`
-  if `key` is larger than all elements return `- (len + 1)` since `lnot (-(len+1)) = len`
-*)
-
-(**/**)
-val union:
-  element array -> int -> int ->
-  element array -> int -> int ->
-  element array -> int
-  -> int
-(**
-  `union src src1ofs src1len src2 src2ofs src2len dst dstofs cmp`
-  assume `src` and `src2` is strictly sorted.
-  for equivalent elements, it is picked from `src`
-  also assume that `dst` is large enough to store all elements
-*)
-
-val intersect:
-  element array -> int -> int ->
-  element array -> int -> int ->
-  element array -> int
-  -> int
-
-val diff:
-  element array -> int -> int ->
-  element array -> int -> int ->
-  element array -> int
-  -> int
-(**/**)

package/lib/ocaml/sort.ml

@@ -1,99 +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.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-(* Merging and sorting *)
-
-open Array
-
-let rec merge order l1 l2 =
-  match l1 with
-    [] -> l2
-  | h1 :: t1 ->
-      match l2 with
-        [] -> l1
-      | h2 :: t2 ->
-          if order h1 h2
-          then h1 :: merge order t1 l2
-          else h2 :: merge order l1 t2
-
-let list order l =
-  let rec initlist = function
-      [] -> []
-    | [e] -> [[e]]
-    | e1::e2::rest ->
-        (if order e1 e2 then [e1;e2] else [e2;e1]) :: initlist rest in
-  let rec merge2 = function
-      l1::l2::rest -> merge order l1 l2 :: merge2 rest
-    | x -> x in
-  let rec mergeall = function
-      [] -> []
-    | [l] -> l
-    | llist -> mergeall (merge2 llist) in
-  mergeall(initlist l)
-
-let swap arr i j =
-  let tmp = unsafe_get arr i in
-  unsafe_set arr i (unsafe_get arr j);
-  unsafe_set arr j tmp
-
-(* There is a known performance bug in the code below.  If you find
-   it, don't bother reporting it.  You're not supposed to use this
-   module anyway. *)
-let array cmp arr =
-  let rec qsort lo hi =
-    if hi - lo >= 6 then begin
-      let mid = (lo + hi) lsr 1 in
-      (* Select median value from among LO, MID, and HI. Rearrange
-         LO and HI so the three values are sorted. This lowers the
-         probability of picking a pathological pivot.  It also
-         avoids extra comparisons on i and j in the two tight "while"
-         loops below. *)
-      if cmp (unsafe_get arr mid) (unsafe_get arr lo) then swap arr mid lo;
-      if cmp (unsafe_get arr hi) (unsafe_get arr mid) then begin
-        swap arr mid hi;
-        if cmp (unsafe_get arr mid) (unsafe_get arr lo) then swap arr mid lo
-      end;
-      let pivot = unsafe_get arr mid in
-      let i = ref (lo + 1) and j = ref (hi - 1) in
-      if not (cmp pivot (unsafe_get arr hi))
-         || not (cmp (unsafe_get arr lo) pivot)
-      then raise (Invalid_argument "Sort.array");
-      while !i < !j do
-        while not (cmp pivot (unsafe_get arr !i)) do incr i done;
-        while not (cmp (unsafe_get arr !j) pivot) do decr j done;
-        if !i < !j then swap arr !i !j;
-        incr i; decr j
-      done;
-      (* Recursion on smaller half, tail-call on larger half *)
-      if !j - lo <= hi - !i then begin
-        qsort lo !j; qsort !i hi
-      end else begin
-        qsort !i hi; qsort lo !j
-      end
-    end in
-  qsort 0 (Array.length arr - 1);
-  (* Finish sorting by insertion sort *)
-  for i = 1 to Array.length arr - 1 do
-    let val_i = (unsafe_get arr i) in
-    if not (cmp (unsafe_get arr (i - 1)) val_i) then begin
-      unsafe_set arr i (unsafe_get arr (i - 1));
-      let j = ref (i - 1) in
-      while !j >= 1 && not (cmp (unsafe_get arr (!j - 1)) val_i) do
-        unsafe_set arr !j (unsafe_get arr (!j - 1));
-        decr j
-      done;
-      unsafe_set arr !j val_i
-    end
-  done

package/lib/ocaml/sort.mli

@@ -1,44 +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.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-(** Sorting and merging lists.
-
-   @deprecated This module is obsolete and exists only for backward
-   compatibility.
-   The sorting functions in {!Array} and {!List} should be used instead.
-   The new functions are faster and use less memory.
-*)
-
-val list : ('a -> 'a -> bool) -> 'a list -> 'a list
-  [@@ocaml.deprecated "Use List.sort instead."]
-(** Sort a list in increasing order according to an ordering predicate.
-   The predicate should return [true] if its first argument is
-   less than or equal to its second argument. *)
-
-val array : ('a -> 'a -> bool) -> 'a array -> unit
-  [@@ocaml.deprecated "Use Array.sort instead."]
-(** Sort an array in increasing order according to an
-   ordering predicate.
-   The predicate should return [true] if its first argument is
-   less than or equal to its second argument.
-   The array is sorted in place. *)
-
-val merge : ('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list
-  [@@ocaml.deprecated "Use List.merge instead."]
-(** Merge two lists according to the given predicate.
-   Assuming the two argument lists are sorted according to the
-   predicate, [merge] returns a sorted list containing the elements
-   from the two lists. The behavior is undefined if the two
-   argument lists were not sorted. *)

package/lib/ocaml/stack.ml

@@ -1,44 +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.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-type 'a t = { mutable c : 'a list; mutable len : int; }
-
-exception Empty
-
-let create () = { c = []; len = 0; }
-
-let clear s = s.c <- []; s.len <- 0
-
-let copy s = { c = s.c; len = s.len; }
-
-let push x s = s.c <- x :: s.c; s.len <- s.len + 1
-
-let pop s =
-  match s.c with
-  | hd::tl -> s.c <- tl; s.len <- s.len - 1; hd
-  | []     -> raise Empty
-
-let top s =
-  match s.c with
-  | hd::_ -> hd
-  | []     -> raise Empty
-
-let is_empty s = (s.c = [])
-
-let length s = s.len
-
-let iter f s = List.iter f s.c
-
-let fold f acc s = List.fold_left f acc s.c

package/lib/ocaml/stack.mli

@@ -1,63 +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.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-(** Last-in first-out stacks.
-
-   This module implements stacks (LIFOs), with in-place modification.
-*)
-
-type 'a t
-(** The type of stacks containing elements of type ['a]. *)
-
-exception Empty
-(** Raised when {!Stack.pop} or {!Stack.top} is applied to an empty stack. *)
-
-
-val create : unit -> 'a t
-(** Return a new stack, initially empty. *)
-
-val push : 'a -> 'a t -> unit
-(** [push x s] adds the element [x] at the top of stack [s]. *)
-
-val pop : 'a t -> 'a
-(** [pop s] removes and returns the topmost element in stack [s],
-   or raises {!Empty} if the stack is empty. *)
-
-val top : 'a t -> 'a
-(** [top s] returns the topmost element in stack [s],
-   or raises {!Empty} if the stack is empty. *)
-
-val clear : 'a t -> unit
-(** Discard all elements from a stack. *)
-
-val copy : 'a t -> 'a t
-(** Return a copy of the given stack. *)
-
-val is_empty : 'a t -> bool
-(** Return [true] if the given stack is empty, [false] otherwise. *)
-
-val length : 'a t -> int
-(** Return the number of elements in a stack. Time complexity O(1) *)
-
-val iter : ('a -> unit) -> 'a t -> unit
-(** [iter f s] applies [f] in turn to all elements of [s],
-   from the element at the top of the stack to the element at the
-   bottom of the stack. The stack itself is unchanged. *)
-
-val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
-(** [fold f accu s] is [(f (... (f (f accu x1) x2) ...) xn)]
-    where [x1] is the top of the stack, [x2] the second element,
-    and [xn] the bottom element. The stack is unchanged.
-    @since 4.03 *)

package/lib/ocaml/stdLabels.ml

@@ -1,24 +0,0 @@
-(**************************************************************************)
-(*                                                                        *)
-(*                                 OCaml                                  *)
-(*                                                                        *)
-(*                Jacques Garrigue, Kyoto University RIMS                 *)
-(*                                                                        *)
-(*   Copyright 2001 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.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-(* Module [StdLabels]: meta-module for labelled libraries *)
-
-module Array = ArrayLabels
-
-module List = ListLabels
-
-module String = StringLabels
-
-module Bytes = BytesLabels

package/lib/ocaml/stdLabels.mli

@@ -1,29 +0,0 @@
-(**************************************************************************)
-(*                                                                        *)
-(*                                 OCaml                                  *)
-(*                                                                        *)
-(*                Jacques Garrigue, Kyoto University RIMS                 *)
-(*                                                                        *)
-(*   Copyright 2001 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.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-(** Standard labeled libraries.
-
-   This meta-module provides labelized version of the {!Array},
-   {!Bytes}, {!List} and {!String} modules.
-
-   They only differ by their labels. Detailed interfaces can be found
-   in [arrayLabels.mli], [bytesLabels.mli], [listLabels.mli]
-   and [stringLabels.mli].
-*)
-
-module Array = ArrayLabels
-module Bytes = BytesLabels
-module List = ListLabels
-module String = StringLabels