chore(int64): remove duplicate functions between Int64 and CCInt64

src/core/CCInt64.mli

@@ -2,7 +2,16 @@
 
 (** {1 Int64}
 
-    Helpers for 64-bit integers
+    Helpers for 64-bit integers.
+
+    This module provides operations on the type int64 of signed 64-bit integers.
+    Unlike the built-in int type, the type int64 is guaranteed to be exactly
+    64-bit wide on all platforms. All arithmetic operations over int64 are taken
+    modulo 2{^64}.
+
+    Performance notice: values of type int64 occupy more memory space than values
+    of type int, and arithmetic operations on int64 are generally slower than
+    those on int. Use int64 only when the application requires exact 64-bit arithmetic.
 
     @since 0.13 *)
 
@@ -36,15 +45,6 @@ val ( mod ) : t -> t -> t
     [x = ((x / y) * y) + (x mod y)].
     If [y = 0], [x mod y] raises [Division_by_zero]. *)
 
-val abs : t -> t
-(** [abs x] returns the absolute value (or magnitude) of its argument [x]. *)
-
-val max_int : t
-(** [max_int] is the greatest representable 64-bit integer, 2{^63} - 1 = [9_223_372_036_854_775_807]. *)
-
-val min_int : t
-(** [min_int] is the smallest representable 64-bit integer, -2{^63} = [-9_223_372_036_854_775_808]. *)
-
 val ( land ) : t -> t -> t
 (** [x land y] is the bitwise logical and of [x] and [y]. *)
 
@@ -99,70 +99,12 @@ end
 
 include module type of Infix
 
-val compare : t -> t -> int
-(** [compare x y] is the comparison function for 64-bit integers, with the same specification as
-    {!Stdlib.compare}.  Along with the type [t], this function [compare]
-    allows the module [CCInt64] to be passed as argument to the functors
-    {!Set.Make} and {!Map.Make}. *)
-
 val hash : t -> int
 (** [hash x] computes the hash of [x].
     Like {!Stdlib.abs (to_int x)}. *)
   
 (** {2 Conversion} *)
 
-val to_int : t -> int
-(** [to_int x] converts the given 64-bit integer [x] (type [int64]) into an
-    integer (type [int]).  On 64-bit platforms, the 64-bit integer
-    is taken modulo 2{^63}, i.e. the high-order bit is lost
-    during the conversion.  On 32-bit platforms, the 64-bit integer
-    is taken modulo 2{^31}, i.e. the top 33 bits are lost
-    during the conversion. *)
-
-val of_int : int -> t
-(** [of_int x] converts the given integer [x] (type [int]) into an
-    64-bit integer (type [int64]).
-    Alias to {!Int64.of_int}.
-    NOTE: used to return an option, but the function actually never fails. *)
-
-val to_int32 : t -> int32
-(** [to_int32 x] converts the given 64-bit integer [x] (type [int64]) to a
-    32-bit integer (type [int32]). The 64-bit integer
-    is taken modulo 2{^32}, i.e. the top 32 bits are lost
-    during the conversion.  *)
-
-val of_int32 : int32 -> t
-(** [of_int32 x] converts the given 32-bit integer [x] (type [int32]) into an
-    64-bit integer (type [int64]).
-    Alias to {!Int64.of_int32}.
-    NOTE: use to return an option, but the function actually never fails. *)
-
-val to_nativeint : t -> nativeint
-(** [to_nativeint x] converts the given 64-bit integer [x] (type [int64]) into a
-    native integer.  On 32-bit platforms, the 64-bit integer
-    is taken modulo 2{^32}.  On 64-bit platforms,
-    the conversion is exact. *)
-
-val of_nativeint : nativeint -> t
-(** [of_nativeint x] converts the given nativeint integer [x] (type [nativeint]) into an
-    64-bit integer (type [int64]).
-    Alias to {!Int64.of_nativeint}.
-    NOTE: use to return an option, but the function actually never fails. *)
-
-val to_float : t -> float
-(** [to_float x] converts the given 64-bit integer [x] into a floating-point number. *)
-
-val of_float : float -> t
-(** [of_float x] converts the given floating-point number [x] into a 64-bit integer,
-    discarding the fractional part (truncate towards 0).
-    The result of the conversion is undefined if, after truncation,
-    the number is outside the range \[{!CCInt64.min_int}, {!CCInt64.max_int}\].
-    Alias to {!Int64.of_float}.
-    NOTE: used to return an option, but the function never fails. *)
-
-val to_string : t -> string
-(** [to_string x] returns the string representation of its argument [x], in decimal. *)
-
 val of_string : string -> t option
 (** [of_string s] is the safe version of {!of_string_exn}. *)