@tellahq/rescript 10.1.4-republish-1 → 10.1.4-republish-2

package/lib/ocaml/filename.mli

@@ -1,134 +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.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-(** Operations on file names. *)
-
-val current_dir_name : string
-(** The conventional name for the current directory (e.g. [.] in Unix). *)
-
-val parent_dir_name : string
-(** The conventional name for the parent of the current directory
-   (e.g. [..] in Unix). *)
-
-val dir_sep : string
-(** The directory separator (e.g. [/] in Unix). @since 3.11.2 *)
-
-val concat : string -> string -> string
-(** [concat dir file] returns a file name that designates file
-   [file] in directory [dir]. *)
-
-val is_relative : string -> bool
-(** Return [true] if the file name is relative to the current
-   directory, [false] if it is absolute (i.e. in Unix, starts
-   with [/]). *)
-
-val is_implicit : string -> bool
-(** Return [true] if the file name is relative and does not start
-   with an explicit reference to the current directory ([./] or
-   [../] in Unix), [false] if it starts with an explicit reference
-   to the root directory or the current directory. *)
-
-val check_suffix : string -> string -> bool
-(** [check_suffix name suff] returns [true] if the filename [name]
-   ends with the suffix [suff]. *)
-
-val chop_suffix : string -> string -> string
-(** [chop_suffix name suff] removes the suffix [suff] from
-   the filename [name]. The behavior is undefined if [name] does not
-   end with the suffix [suff]. *)
-
-val extension : string -> string
-(** [extension name] is the shortest suffix [ext] of [name0] where:
-
-    - [name0] is the longest suffix of [name] that does not
-      contain a directory separator;
-    - [ext] starts with a period;
-    - [ext] is preceded by at least one non-period character
-      in [name0].
-
-    If such a suffix does not exist, [extension name] is the empty
-    string.
-
-    @since 4.04
-*)
-
-val remove_extension : string -> string
-(** Return the given file name without its extension, as defined
-    in {!Filename.extension}. If the extension is empty, the function
-    returns the given file name.
-
-    The following invariant holds for any file name [s]:
-
-    [remove_extension s ^ extension s = s]
-
-    @since 4.04
-*)
-
-val chop_extension : string -> string
-(** Same as {!Filename.remove_extension}, but raise [Invalid_argument]
-    if the given name has an empty extension. *)
-
-
-val basename : string -> string
-(** Split a file name into directory name / base file name.
-   If [name] is a valid file name, then [concat (dirname name) (basename name)]
-   returns a file name which is equivalent to [name]. Moreover,
-   after setting the current directory to [dirname name] (with {!Sys.chdir}),
-   references to [basename name] (which is a relative file name)
-   designate the same file as [name] before the call to {!Sys.chdir}.
-
-   This function conforms to the specification of POSIX.1-2008 for the
-   [basename] utility. *)
-
-val dirname : string -> string
-(** See {!Filename.basename}.
-   This function conforms to the specification of POSIX.1-2008 for the
-   [dirname] utility. *)
-
-
-val get_temp_dir_name : unit -> string
-(** The name of the temporary directory:
-    Under Unix, the value of the [TMPDIR] environment variable, or "/tmp"
-    if the variable is not set.
-    Under Windows, the value of the [TEMP] environment variable, or "."
-    if the variable is not set.
-    The temporary directory can be changed with {!Filename.set_temp_dir_name}.
-    @since 4.00.0
-*)
-
-val set_temp_dir_name : string -> unit
-(** Change the temporary directory returned by {!Filename.get_temp_dir_name}
-    and used by {!Filename.temp_file} and {!Filename.open_temp_file}.
-    @since 4.00.0
-*)
-
-val temp_dir_name : string
-  [@@ocaml.deprecated "Use Filename.get_temp_dir_name instead"]
-(** The name of the initial temporary directory:
-    Under Unix, the value of the [TMPDIR] environment variable, or "/tmp"
-    if the variable is not set.
-    Under Windows, the value of the [TEMP] environment variable, or "."
-    if the variable is not set.
-    @deprecated You should use {!Filename.get_temp_dir_name} instead.
-    @since 3.09.1
-*)
-
-val quote : string -> string
-(** Return a quoted version of a file name, suitable for use as
-    one argument in a command line, escaping all meta-characters.
-    Warning: under Windows, the output is only suitable for use
-    with programs that follow the standard Windows quoting
-    conventions.
- *)

package/lib/ocaml/genlex.ml

@@ -1,201 +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 token =
-    Kwd of string
-  | Ident of string
-  | Int of int
-  | Float of float
-  | String of string
-  | Char of char
-
-(* The string buffering machinery *)
-
-let initial_buffer = Bytes.create 32
-
-let buffer = ref initial_buffer
-let bufpos = ref 0
-
-let reset_buffer () = buffer := initial_buffer; bufpos := 0
-
-let store c =
-  if !bufpos >= Bytes.length !buffer then begin
-    let newbuffer = Bytes.create (2 * !bufpos) in
-    Bytes.blit !buffer 0 newbuffer 0 !bufpos;
-    buffer := newbuffer
-  end;
-  Bytes.set !buffer !bufpos c;
-  incr bufpos
-
-let get_string () =
-  let s = Bytes.sub_string !buffer 0 !bufpos in buffer := initial_buffer; s
-
-(* The lexer *)
-
-let make_lexer keywords =
-  let kwd_table = Hashtbl.create 17 in
-  List.iter (fun s -> Hashtbl.add kwd_table s (Kwd s)) keywords;
-  let ident_or_keyword id =
-    try Hashtbl.find kwd_table id with
-      Not_found -> Ident id
-  and keyword_or_error c =
-    let s = String.make 1 c in
-    try Hashtbl.find kwd_table s with
-      Not_found -> raise (Stream.Error ("Illegal character " ^ s))
-  in
-  let rec next_token (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some (' ' | '\010' | '\013' | '\009' | '\026' | '\012') ->
-        Stream.junk strm__; next_token strm__
-    | Some ('A'..'Z' | 'a'..'z' | '_' | '\192'..'\255' as c) ->
-        Stream.junk strm__;
-        let s = strm__ in reset_buffer (); store c; ident s
-    | Some
-        ('!' | '%' | '&' | '$' | '#' | '+' | '/' | ':' | '<' | '=' | '>' |
-         '?' | '@' | '\\' | '~' | '^' | '|' | '*' as c) ->
-        Stream.junk strm__;
-        let s = strm__ in reset_buffer (); store c; ident2 s
-    | Some ('0'..'9' as c) ->
-        Stream.junk strm__;
-        let s = strm__ in reset_buffer (); store c; number s
-    | Some '\'' ->
-        Stream.junk strm__;
-        let c =
-          try char strm__ with
-            Stream.Failure -> raise (Stream.Error "")
-        in
-        begin match Stream.peek strm__ with
-          Some '\'' -> Stream.junk strm__; Some (Char c)
-        | _ -> raise (Stream.Error "")
-        end
-    | Some '\"' ->
-        Stream.junk strm__;
-        let s = strm__ in reset_buffer (); Some (String (string s))
-    | Some '-' -> Stream.junk strm__; neg_number strm__
-    | Some '(' -> Stream.junk strm__; maybe_comment strm__
-    | Some c -> Stream.junk strm__; Some (keyword_or_error c)
-    | _ -> None
-  and ident (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some
-        ('A'..'Z' | 'a'..'z' | '\192'..'\255' | '0'..'9' | '_' | '\'' as c) ->
-        Stream.junk strm__; let s = strm__ in store c; ident s
-    | _ -> Some (ident_or_keyword (get_string ()))
-  and ident2 (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some
-        ('!' | '%' | '&' | '$' | '#' | '+' | '-' | '/' | ':' | '<' | '=' |
-         '>' | '?' | '@' | '\\' | '~' | '^' | '|' | '*' as c) ->
-        Stream.junk strm__; let s = strm__ in store c; ident2 s
-    | _ -> Some (ident_or_keyword (get_string ()))
-  and neg_number (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some ('0'..'9' as c) ->
-        Stream.junk strm__;
-        let s = strm__ in reset_buffer (); store '-'; store c; number s
-    | _ -> let s = strm__ in reset_buffer (); store '-'; ident2 s
-  and number (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some ('0'..'9' as c) ->
-        Stream.junk strm__; let s = strm__ in store c; number s
-    | Some '.' ->
-        Stream.junk strm__; let s = strm__ in store '.'; decimal_part s
-    | Some ('e' | 'E') ->
-        Stream.junk strm__; let s = strm__ in store 'E'; exponent_part s
-    | _ -> Some (Int (int_of_string (get_string ())))
-  and decimal_part (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some ('0'..'9' as c) ->
-        Stream.junk strm__; let s = strm__ in store c; decimal_part s
-    | Some ('e' | 'E') ->
-        Stream.junk strm__; let s = strm__ in store 'E'; exponent_part s
-    | _ -> Some (Float (float_of_string (get_string ())))
-  and exponent_part (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some ('+' | '-' as c) ->
-        Stream.junk strm__; let s = strm__ in store c; end_exponent_part s
-    | _ -> end_exponent_part strm__
-  and end_exponent_part (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some ('0'..'9' as c) ->
-        Stream.junk strm__; let s = strm__ in store c; end_exponent_part s
-    | _ -> Some (Float (float_of_string (get_string ())))
-  and string (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some '\"' -> Stream.junk strm__; get_string ()
-    | Some '\\' ->
-        Stream.junk strm__;
-        let c =
-          try escape strm__ with
-            Stream.Failure -> raise (Stream.Error "")
-        in
-        let s = strm__ in store c; string s
-    | Some c -> Stream.junk strm__; let s = strm__ in store c; string s
-    | _ -> raise Stream.Failure
-  and char (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some '\\' ->
-        Stream.junk strm__;
-        begin try escape strm__ with
-          Stream.Failure -> raise (Stream.Error "")
-        end
-    | Some c -> Stream.junk strm__; c
-    | _ -> raise Stream.Failure
-  and escape (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some 'n' -> Stream.junk strm__; '\n'
-    | Some 'r' -> Stream.junk strm__; '\r'
-    | Some 't' -> Stream.junk strm__; '\t'
-    | Some ('0'..'9' as c1) ->
-        Stream.junk strm__;
-        begin match Stream.peek strm__ with
-          Some ('0'..'9' as c2) ->
-            Stream.junk strm__;
-            begin match Stream.peek strm__ with
-              Some ('0'..'9' as c3) ->
-                Stream.junk strm__;
-                Char.chr
-                  ((Char.code c1 - 48) * 100 + (Char.code c2 - 48) * 10 +
-                     (Char.code c3 - 48))
-            | _ -> raise (Stream.Error "")
-            end
-        | _ -> raise (Stream.Error "")
-        end
-    | Some c -> Stream.junk strm__; c
-    | _ -> raise Stream.Failure
-  and maybe_comment (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some '*' ->
-        Stream.junk strm__; let s = strm__ in comment s; next_token s
-    | _ -> Some (keyword_or_error '(')
-  and comment (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some '(' -> Stream.junk strm__; maybe_nested_comment strm__
-    | Some '*' -> Stream.junk strm__; maybe_end_comment strm__
-    | Some _ -> Stream.junk strm__; comment strm__
-    | _ -> raise Stream.Failure
-  and maybe_nested_comment (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some '*' -> Stream.junk strm__; let s = strm__ in comment s; comment s
-    | Some _ -> Stream.junk strm__; comment strm__
-    | _ -> raise Stream.Failure
-  and maybe_end_comment (strm__ : _ Stream.t) =
-    match Stream.peek strm__ with
-      Some ')' -> Stream.junk strm__; ()
-    | Some '*' -> Stream.junk strm__; maybe_end_comment strm__
-    | Some _ -> Stream.junk strm__; comment strm__
-    | _ -> raise Stream.Failure
-  in
-  fun input -> Stream.from (fun _count -> next_token input)

package/lib/ocaml/genlex.mli

@@ -1,73 +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.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-(** A generic lexical analyzer.
-
-
-   This module implements a simple 'standard' lexical analyzer, presented
-   as a function from character streams to token streams. It implements
-   roughly the lexical conventions of OCaml, but is parameterized by the
-   set of keywords of your language.
-
-
-   Example: a lexer suitable for a desk calculator is obtained by
-   {[     let lexer = make_lexer ["+";"-";"*";"/";"let";"="; "("; ")"]  ]}
-
-   The associated parser would be a function from [token stream]
-   to, for instance, [int], and would have rules such as:
-
-   {[
-           let rec parse_expr = parser
-             | [< n1 = parse_atom; n2 = parse_remainder n1 >] -> n2
-           and parse_atom = parser
-             | [< 'Int n >] -> n
-             | [< 'Kwd "("; n = parse_expr; 'Kwd ")" >] -> n
-           and parse_remainder n1 = parser
-             | [< 'Kwd "+"; n2 = parse_expr >] -> n1+n2
-             | [< >] -> n1
-   ]}
-
-   One should notice that the use of the [parser] keyword and associated
-   notation for streams are only available through camlp4 extensions. This
-   means that one has to preprocess its sources {i e. g.} by using the
-   ["-pp"] command-line switch of the compilers.
-*)
-
-(** The type of tokens. The lexical classes are: [Int] and [Float]
-   for integer and floating-point numbers; [String] for
-   string literals, enclosed in double quotes; [Char] for
-   character literals, enclosed in single quotes; [Ident] for
-   identifiers (either sequences of letters, digits, underscores
-   and quotes, or sequences of 'operator characters' such as
-   [+], [*], etc); and [Kwd] for keywords (either identifiers or
-   single 'special characters' such as [(], [}], etc). *)
-type token =
-    Kwd of string
-  | Ident of string
-  | Int of int
-  | Float of float
-  | String of string
-  | Char of char
-
-val make_lexer : string list -> char Stream.t -> token Stream.t
-(** Construct the lexer function. The first argument is the list of
-   keywords. An identifier [s] is returned as [Kwd s] if [s]
-   belongs to this list, and as [Ident s] otherwise.
-   A special character [s] is returned as [Kwd s] if [s]
-   belongs to this list, and cause a lexical error (exception
-   {!Stream.Error} with the offending lexeme as its parameter) otherwise.
-   Blanks and newlines are skipped. Comments delimited by [(*] and [*)]
-   are skipped as well, and can be nested. A {!Stream.Failure} exception
-   is raised if end of stream is unexpectedly reached.*)

package/lib/ocaml/hashmap.cppo.ml

@@ -1,214 +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 Library General Public License, with    *)
-(*  the special exception on linking described in file ../LICENSE.     *)
-(*                                                                     *)
-(***********************************************************************)
-(**  Adapted by Hongbo Zhang, Authors of ReScript 2017                           *)
-
-#ifdef TYPE_STRING
-type key = string
-type seed = int
-external caml_hash_mix_string : seed -> string -> seed  = "?hash_mix_string"
-external final_mix : seed -> seed = "?hash_final_mix"
-let hash (s : key) =   
-  final_mix  (caml_hash_mix_string 0 s )
-#elif defined TYPE_INT
-type key = int
-type seed = int
-external caml_hash_mix_int : seed -> int -> seed  = "?hash_mix_int"
-external final_mix : seed -> seed = "?hash_final_mix"
-let hash (s : key) = 
-  final_mix (caml_hash_mix_int 0 s)
-#else 
-  [%error "unknown type"]
-#endif
-
-module N = Belt_internalBuckets
-module C = Belt_internalBucketsType
-module A = Belt_Array
-
-
-type 'b t = (unit, unit, key,'b) N.t
-
-
-let rec copyBucketReHash  ~h_buckets ~ndata_tail  (old_bucket : _ N.bucket  C.opt ) = 
-  match C.toOpt old_bucket with 
-  | None -> ()
-  | Some cell ->
-    let nidx = hash cell.key land (A.length h_buckets - 1) in 
-    let v = C.return cell in 
-    begin match C.toOpt (A.getUnsafe ndata_tail nidx) with
-      | None -> 
-        A.setUnsafe h_buckets nidx  v
-      | Some tail ->
-        tail.N.next <- v  (* cell put at the end *)            
-    end;          
-    A.setUnsafe ndata_tail nidx  v;
-    copyBucketReHash  ~h_buckets ~ndata_tail  cell.next
-
-
-let resize  h =
-  let odata = h.C.buckets in
-  let osize = A.length odata in
-  let nsize = osize * 2 in
-  if nsize >= osize then begin (* no overflow *)
-    let h_buckets = A.makeUninitialized nsize  in
-    let ndata_tail = A.makeUninitialized nsize  in (* keep track of tail *)
-    h.C.buckets <- h_buckets;          (* so that indexfun sees the new bucket count *)
-    for i = 0 to osize - 1 do
-      copyBucketReHash  ~h_buckets ~ndata_tail  (A.getUnsafe odata i)
-    done;
-    for i = 0 to nsize - 1 do
-      match C.toOpt (A.getUnsafe ndata_tail i) with
-      | None -> ()
-      | Some tail -> tail.next <- C.emptyOpt
-    done
-  end
-
-
-let rec replaceInBucket  (key : key) info cell = 
-    if  cell.N.key = key 
-    then
-      begin
-        cell.N.value <- info;
-        false
-      end
-    else
-    match C.toOpt cell.next with 
-    | None -> true 
-    | Some cell -> 
-      replaceInBucket key info cell
-
-let set  h (key : key) value =
-  let h_buckets = h.C.buckets in 
-  let buckets_len = A.length h_buckets in 
-  let i = hash key land (buckets_len - 1) in 
-  let l = A.getUnsafe h_buckets i in  
-  (match C.toOpt l with 
-  | None -> 
-    A.setUnsafe h_buckets i (C.return {N.key; value; next = C.emptyOpt});
-    h.C.size <- (h.C.size + 1);
-  | Some bucket -> 
-      if replaceInBucket key value bucket then begin
-        A.setUnsafe h_buckets i (C.return {N.key; value; next = l});
-        h.C.size <- (h.C.size + 1);
-      end   
-    );
-    if h.C.size > buckets_len lsl 1 then resize h 
-
-
-
-let rec removeInBucket h h_buckets  i (key : key) prec buckets =
-  match C.toOpt buckets with
-  | None -> ()
-  | Some cell  ->
-    let cell_next = cell.N.next in 
-    if  cell.N.key = key 
-    then 
-      begin
-        prec.N.next <-cell_next;
-        h.C.size <- (h.C.size - 1);        
-      end
-    else removeInBucket  h h_buckets i key cell cell_next
-
-let remove  h key =  
-  let h_buckets = h.C.buckets in 
-  let i = hash key land (A.length h_buckets - 1) in  
-  let bucket = (A.getUnsafe h_buckets i) in 
-  match C.toOpt bucket with 
-  | None -> ()
-  | Some cell -> 
-    if cell.N.key = key then 
-    begin 
-      A.setUnsafe h_buckets i cell.next;
-      h.C.size <- (h.C.size - 1)
-    end 
-    else 
-      removeInBucket  h h_buckets i key cell cell.next
-
-
-
-let rec getAux  (key : key) buckets = 
-  match C.toOpt buckets with 
-  | None ->
-    None
-  | Some cell ->
-    if key = cell.N.key  then Some cell.N.value 
-    else getAux key  cell.next
-
-let get  h (key : key) =
-  let h_buckets = h.C.buckets in 
-  let nid = hash key  land (A.length h_buckets - 1) in 
-  match C.toOpt (A.getUnsafe h_buckets nid) with
-  | None -> None
-  | Some cell1 ->
-    if key = cell1.N.key  then Some cell1.N.value else
-      match C.toOpt cell1.N.next with
-      | None -> None
-      | Some cell2 ->
-        if  key = cell2.N.key  then Some cell2.N.value else
-          match C.toOpt cell2.N.next with
-          | None -> None
-          | Some cell3 ->
-            if  key = cell3.N.key  then Some cell3.N.value
-            else getAux  key cell3.N.next
-
-
-let rec memInBucket (key : key) cell = 
-    cell.N.key  = key  ||
-    (match C.toOpt cell.next with 
-    | None -> false
-    | Some nextCell -> memInBucket  key nextCell
-     )
-    
-let has h key =
-  let h_buckets = h.C.buckets in 
-  let nid = hash key land (A.length h_buckets - 1) in 
-  let bucket = A.getUnsafe h_buckets nid in 
-  match C.toOpt bucket with 
-  | None -> false
-  | Some bucket -> 
-    memInBucket  key bucket
-
-
-let make ~hintSize = C.make ~hintSize ~hash:() ~eq:()
-let clear = C.clear
-let size h = h.C.size
-let forEachU = N.forEachU 
-let forEach = N.forEach
-let reduceU = N.reduceU
-let reduce = N.reduce               
-let logStats = N.logStats
-let keepMapInPlaceU = N.keepMapInPlaceU 
-let keepMapInPlace = N.keepMapInPlace
-let toArray = N.toArray
-let copy = N.copy
-let keysToArray = N.keysToArray
-let valuesToArray = N.valuesToArray
-let getBucketHistogram = N.getBucketHistogram 
-let isEmpty = C.isEmpty
-
-let fromArray arr = 
-  let len = A.length arr in 
-  let v = make ~hintSize:len in 
-  for i = 0 to len - 1 do 
-    let k,value = (A.getUnsafe arr i) in
-    set v k value
-  done ;
-  v
-
-(* TOOD: optimize heuristics for resizing *)  
-let mergeMany h arr =   
-  let len = A.length arr in 
-  for i = 0 to len - 1 do 
-    let k,v = (A.getUnsafe arr i) in
-    set h k v 
-  done
-

package/lib/ocaml/hashmap.cppo.mli

@@ -1,54 +0,0 @@
-#ifdef TYPE_STRING
-type key = string
-#elif defined TYPE_INT
-type key = int
-#else
-[%error "unknown type"]
-#endif
-
-
-type 'b t
-
-
-val make:  hintSize:int -> 'b t
-
-val clear: 'b t -> unit
-
-val isEmpty: _ t -> bool
-
-val set: 'a t -> key -> 'a -> unit
-(**
-  `setDone tbl k v` if `k` does not exist,
-  add the binding `k,v`, otherwise, update the old value with the new
-  `v`
-*)
-
-
-val copy: 'a t -> 'a t
-val get:  'a t -> key -> 'a option
-
-val has:  'b  t -> key -> bool
-
-val remove: 'a t -> key -> unit
-
-val forEachU: 'b t -> (key -> 'b -> unit [@bs]) -> unit
-val forEach: 'b t -> (key -> 'b -> unit) -> unit
-
-val reduceU: 'b t -> 'c -> ('c -> key -> 'b ->  'c [@bs]) -> 'c
-val reduce: 'b t -> 'c -> ('c -> key -> 'b ->  'c) -> 'c
-
-val keepMapInPlaceU: 'a t ->  (key -> 'a -> 'a option [@bs]) -> unit
-val keepMapInPlace: 'a t ->  (key -> 'a -> 'a option) -> unit
-
-
-val size: _ t -> int
-
-
-val toArray: 'a t -> (key * 'a) array
-val keysToArray: 'a t -> key array
-val valuesToArray: 'a t -> 'a array
-val fromArray: (key * 'a) array -> 'a t
-val mergeMany: 'a t -> (key * 'a) array -> unit
-val getBucketHistogram: _ t -> int array
-val logStats: _ t -> unit
-