v0.18~preview.130.26+1192

Author: public-release

LICENSE.md

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2008--2024 Jane Street Group, LLC <[email protected]>
+Copyright (c) 2008--2025 Jane Street Group, LLC <[email protected]>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

ansi_kernel/src/ansi_kernel.mli

@@ -31,9 +31,9 @@ module Color : sig
 end
 
 module Attr : sig
-  (** Styling attributes: these provide most of the ANSI display attributes,
-      but not directly `Reset, `Blink and `Hidden, so as to explicitly
-      discourage their use in general code. *)
+  (** Styling attributes: these provide most of the ANSI display attributes, but not
+      directly `Reset, `Blink and `Hidden, so as to explicitly discourage their use in
+      general code. *)
   type t =
     [ `Bright
     | `Dim

ansi_kernel/src/color_256.mli

@@ -1,94 +1,89 @@
-(** Support for 256-color handling on terminals/consoles.  Note that the
-    functions [of_rgb6_exn] and [of_rgb6] return values within the 6x6x6
-    color-cube space, even though equivalent duplicates exist in the first 16
-    and last 24 colors (a "best-fit-equivalent" function could be added some
-    day, if there ever becomes a requirement for it -- see note 2 below).
+(** Support for 256-color handling on terminals/consoles. Note that the functions
+    [of_rgb6_exn] and [of_rgb6] return values within the 6x6x6 color-cube space, even
+    though equivalent duplicates exist in the first 16 and last 24 colors (a
+    "best-fit-equivalent" function could be added some day, if there ever becomes a
+    requirement for it -- see note 2 below).
 
-    NOTE 1: the color-cube is not linear in terms of RGB levels, but is
-    "shifted" towards brighter values (as opposed to a logarithmic or other
-    mapping). Visually, the "rgb6" values 0 to 5 (used in [of_rgb6_exn] and
-    encoded in the 256-color palette values) map into RGB levels as follows:
+    NOTE 1: the color-cube is not linear in terms of RGB levels, but is "shifted" towards
+    brighter values (as opposed to a logarithmic or other mapping). Visually, the "rgb6"
+    values 0 to 5 (used in [of_rgb6_exn] and encoded in the 256-color palette values) map
+    into RGB levels as follows:
 
     {v
     Cube-val:  0           1    2    3    4    5
        v       +-----------+----+----+----+----+
       RGB:     0           95   135  175  215  255
     v}
 
-    The floating-point values used in [of_rgb] are {e not} weighted in the same
-    way, but are rounded to the nearest cube-value -- a value of 0.5 (50% or
-    127.5/255) would result in a color-cube value of 2, for example.  Any level
-    less than 0.187 (approx.) maps to 0 (black) and greater than 0.921 to 5
-    (white).
+    The floating-point values used in [of_rgb] are {e not} weighted in the same way, but
+    are rounded to the nearest cube-value -- a value of 0.5 (50% or 127.5/255) would
+    result in a color-cube value of 2, for example. Any level less than 0.187 (approx.)
+    maps to 0 (black) and greater than 0.921 to 5 (white).
 
-    NOTE 2: is is {e not} recommended to use the 256-color palette for
-    representing the 16 (8 * 2) 'primary' colors.  The standard [`Black],
-    [`Blue], etc. attributes are recommended for these.
-*)
+    NOTE 2: is is {e not} recommended to use the 256-color palette for representing the 16
+    (8 * 2) 'primary' colors. The standard [`Black], [`Blue], etc. attributes are
+    recommended for these. *)
 
 type t [@@deriving sexp_of, compare, hash, equal]
 
 val to_int : t -> int
 val of_int_exn : int -> t
 
-(** Takes an RGB triple with values in the range [0,5] (inclusive) and returns
-    the appropriate 256-color palette value.  Will throw an exception if any of
-    the inputs are out-of-range.  Note that the input values are weighted as
-    described above. *)
+(** Takes an RGB triple with values in the range [0,5] (inclusive) and returns the
+    appropriate 256-color palette value. Will throw an exception if any of the inputs are
+    out-of-range. Note that the input values are weighted as described above. *)
 val of_rgb6_exn : int * int * int -> t
 
-(** Takes an RGB triple with float values in the closed (inclusive) interval
-    [0,1] and returns the nearest (rounded) 256-color palette value.
-    Out-of-bound values are clamped to the range.  The inputs are {e not}
-    weighted, unlike [of_rgb6_exn] as described above. *)
+(** Takes an RGB triple with float values in the closed (inclusive) interval [0,1] and
+    returns the nearest (rounded) 256-color palette value. Out-of-bound values are clamped
+    to the range. The inputs are {e not} weighted, unlike [of_rgb6_exn] as described
+    above. *)
 val of_rgb : float * float * float -> t
 
-(** Takes an RGB triple with integer values in the closed (inclusive) range
-    [0,255] and returns the nearest (rounded) 256-color palette color-cube
-    value.  Out-of-bound values are clamped to the range.  The inputs are
-    {e not} weighted, unlike [of_rgb6_exn] as described above. *)
+(** Takes an RGB triple with integer values in the closed (inclusive) range [0,255] and
+    returns the nearest (rounded) 256-color palette color-cube value. Out-of-bound values
+    are clamped to the range. The inputs are {e not} weighted, unlike [of_rgb6_exn] as
+    described above. *)
 val of_rgb_8bit : int * int * int -> t
 
-(** Takes an RGB triple with integer values in the closed (inclusive) range
-    [0,1000] and returns the nearest (rounded) 256-color palette color-cube
-    value.  Out-of-bound values are clamped to the range.  The inputs are {e not}
-    weighted, unlike [of_rgb6_exn] as described above. *)
+(** Takes an RGB triple with integer values in the closed (inclusive) range [0,1000] and
+    returns the nearest (rounded) 256-color palette color-cube value. Out-of-bound values
+    are clamped to the range. The inputs are {e not} weighted, unlike [of_rgb6_exn] as
+    described above. *)
 val of_rgb_int1k : int * int * int -> t
 
-(** Takes a grayscale level from [0-23] (inclusive, not-black-to-not-white)
-    and returns the appropriate 256-color palette value.  Will throw an
-    exception if the input value is out-of-range. *)
+(** Takes a grayscale level from [0-23] (inclusive, not-black-to-not-white) and returns
+    the appropriate 256-color palette value. Will throw an exception if the input value is
+    out-of-range. *)
 val of_gray24_exn : int -> t
 
-(** Takes a color palette value and returns, for color-cube and grayscale
-    palette values, an approximated [`RGB] triple with each component in the
-    range [0,1];  for the first 16 values, [`Primary] followed by the specific
-    palette index is returned, as these are not consistently defined. *)
+(** Takes a color palette value and returns, for color-cube and grayscale palette values,
+    an approximated [`RGB] triple with each component in the range [0,1]; for the first 16
+    values, [`Primary] followed by the specific palette index is returned, as these are
+    not consistently defined. *)
 val to_rgb : t -> [> `Primary of int | `RGB of float * float * float ]
 
-(** Takes a color palette value and returns a hex-encoded RGB 24-bit triplet,
-    with a leading '#'.  I.e. "#000000" through "#ffffff".  The values
-    returned for the first 16 (primary) colors follow the Windows Console
-    scheme, as documented here: https://en.wikipedia.org/wiki/ANSI_escape_code .
-*)
+(** Takes a color palette value and returns a hex-encoded RGB 24-bit triplet, with a
+    leading '#'. I.e. "#000000" through "#ffffff". The values returned for the first 16
+    (primary) colors follow the Windows Console scheme, as documented here:
+    https://en.wikipedia.org/wiki/ANSI_escape_code . *)
 val to_rgb_hex24 : t -> string
 
-(** Takes a color palette value and returns an approximate luminance value
-    in the closed interval [0,1]. *)
+(** Takes a color palette value and returns an approximate luminance value in the closed
+    interval [0,1]. *)
 val to_luma : t -> float
 
-(** Takes a color palette value and returns a triple of RGB integers in
-    the closed interval [0,255]. *)
+(** Takes a color palette value and returns a triple of RGB integers in the closed
+    interval [0,255]. *)
 val to_rgb_8bit : t -> int * int * int
 
-(** Takes a color palette value and returns a triple of RGB integers in
-    the closed interval [0,1000]. *)
+(** Takes a color palette value and returns a triple of RGB integers in the closed
+    interval [0,1000]. *)
 val to_rgb_int1k : t -> int * int * int
 
-(** Takes a color palette value and returns a triple of RGB integers in
-    the closed interval [0,5].  For color-cube palette values, this simply
-    un-does [of_rgb6_exn].  For others, it will return the closest matching
-    value in the color-cube. *)
+(** Takes a color palette value and returns a triple of RGB integers in the closed
+    interval [0,5]. For color-cube palette values, this simply un-does [of_rgb6_exn]. For
+    others, it will return the closest matching value in the color-cube. *)
 val to_rgb6 : t -> int * int * int
 
 module Stable : sig

balanced_reducer/src/balanced_reducer.mli

@@ -9,22 +9,22 @@ type 'a t [@@deriving sexp_of]
 include Invariant.S1 with type 'a t := 'a t
 
 (** [create_exn ~len ~reduce] creates a balanced reducer of length [len], all of whose
-    elements are [None].  It raises if [len < 1]. *)
+    elements are [None]. It raises if [len < 1]. *)
 val create_exn
   :  ?sexp_of_a:('a -> Sexp.t) (** for improved error messages *)
   -> unit
   -> len:int
   -> reduce:('a -> 'a -> 'a)
   -> 'a t
 
-(** [set_exn t i a] updates the value at index [i] to [Some a].  It raises if [i] is out
-    of bounds. *)
+(** [set_exn t i a] updates the value at index [i] to [Some a]. It raises if [i] is out of
+    bounds. *)
 val set_exn : 'a t -> int -> 'a -> unit
 
-(** [get_exn t i] gets the value at index [i].  It raises if [i] is out of bounds, or
+(** [get_exn t i] gets the value at index [i]. It raises if [i] is out of bounds, or
     [set_exn t i] has never been called. *)
 val get_exn : 'a t -> int -> 'a
 
-(** [compute_exn t] computes the value of the fold.  It raises if any values of the array
+(** [compute_exn t] computes the value of the fold. It raises if any values of the array
     are [None]. *)
 val compute_exn : 'a t -> 'a

balanced_reducer/test/balanced_reducer_test.ml

@@ -0,0 +1 @@
+module Test_balanced_reducer = Test_balanced_reducer

binary_packing/src/binary_packing.mli

@@ -6,8 +6,7 @@
     [pos] arguments refer to the location in the buf string.
 
     We support big- and little-endian ints. Note that for an 8-bit (1-byte) integer, there
-    is no difference, because endian-ness only changes the order of bytes, not bits.
-*)
+    is no difference, because endian-ness only changes the order of bytes, not bits. *)
 
 open! Core
 open! Import
@@ -39,9 +38,7 @@ val pack_unsigned_8 : buf:bytes -> pos:int -> int -> unit
                 unpack_signed_64_int |    21 ns |    0 ns |        M
         pack_signed_64_little_endian |     8 ns |    0 ns |
       unpack_signed_64_little_endian |     9 ns |    0 ns |        M
-
- v}
-*)
+    v} *)
 val unpack_signed_16 : byte_order:endian -> buf:bytes -> pos:int -> int
 
 val pack_signed_16 : byte_order:endian -> buf:bytes -> pos:int -> int -> unit
@@ -95,8 +92,8 @@ val pack_float : byte_order:endian -> buf:bytes -> pos:int -> float -> unit
     plus the length of the padding equals the fixed length. *)
 
 (** Decode the fixed-length tail-padded string having length [len] from [buf] starting at
-    [pos]. Return a string containing only the non-padding characters. The default
-    padding is '\x00'. *)
+    [pos]. Return a string containing only the non-padding characters. The default padding
+    is '\x00'. *)
 val unpack_tail_padded_fixed_string
   :  ?padding:char
   -> buf:Bytes.t
@@ -106,9 +103,9 @@ val unpack_tail_padded_fixed_string
   -> string
 
 (** Encode and pack the given string as a tail padded fixed length string having length
-    [len]. Place it in [buf] starting at position [pos].  If the length of the string is
+    [len]. Place it in [buf] starting at position [pos]. If the length of the string is
     less then [len] pad it with the padding characters until its length is equal to [len].
-    If the string is longer than [len] raise [Invalid_argument].  The default padding is
+    If the string is longer than [len] raise [Invalid_argument]. The default padding is
     '\x00'. *)
 val pack_tail_padded_fixed_string
   :  ?padding:char

binary_packing/test-bin/test_binary_packing.ml

@@ -58,7 +58,7 @@ let test byte_order =
           string_of_int
   ; "[pack|unpack]_signed_32"
     >:: inverses
-          (fun n -> Int32.( + ) (Int32.of_int_exn n))
+          (fun n m -> Int32.( + ) (Int32.of_int_exn n) m)
           1
           B.pack_signed_32
           B.unpack_signed_32

binary_packing/test/binary_packing_test.ml

@@ -0,0 +1,2 @@
+module Import = Import
+module Test_binary_packing = Test_binary_packing

bounded_int_table/src/bounded_int_table.ml

@@ -72,20 +72,15 @@ let invariant invariant_key invariant_data t =
   with
   | exn ->
     let sexp_of_key = sexp_of_key t in
-    failwiths
-      ~here:[%here]
-      "invariant failed"
-      (exn, t)
-      [%sexp_of: exn * (key, _) t_detailed]
+    failwiths "invariant failed" (exn, t) [%sexp_of: exn * (key, _) t_detailed]
 ;;
 
 let debug = ref false
 let check_invariant t = if !debug then invariant ignore ignore t
 let is_empty t = length t = 0
 
 let create ?sexp_of_key ~num_keys ~key_to_int () =
-  if num_keys < 0
-  then failwiths ~here:[%here] "num_keys must be nonnegative" num_keys [%sexp_of: int];
+  if num_keys < 0 then failwiths "num_keys must be nonnegative" num_keys [%sexp_of: int];
   let t =
     { num_keys
     ; sexp_of_key
@@ -163,7 +158,6 @@ let entry_opt t key =
   | _ ->
     let sexp_of_key = sexp_of_key t in
     failwiths
-      ~here:[%here]
       "key's index out of range"
       (key, index, `Should_be_between_0_and (t.num_keys - 1))
       [%sexp_of: key * int * [ `Should_be_between_0_and of int ]]
@@ -181,7 +175,6 @@ let find_exn t key =
   | None ->
     let sexp_of_key = sexp_of_key t in
     failwiths
-      ~here:[%here]
       "Bounded_int_table.find_exn got unknown key"
       (key, t)
       [%sexp_of: key * (key, _) t]
@@ -230,7 +223,6 @@ let add_exn t ~key ~data =
   | `Duplicate _ ->
     let sexp_of_key = sexp_of_key t in
     failwiths
-      ~here:[%here]
       "Bounded_int_table.add_exn of key whose index is already present"
       (key, t.key_to_int key)
       [%sexp_of: key * int]
@@ -250,7 +242,6 @@ let remove t key =
        | None ->
          let sexp_of_key = sexp_of_key t in
          failwiths
-           ~here:[%here]
            "Bounded_int_table.remove bug"
            (key, last, t)
            [%sexp_of: key * int * (key, _) t_detailed]

bounded_int_table/src/bounded_int_table.mli

@@ -4,10 +4,10 @@
     is willing to pay a space cost for the speed.
 
     [Bounded_int_table] presents a subset of the [Hashtbl] interface. The key type can be
-    any type, but table creation requires a [key_to_int] function, which will be used
-    to extract the integer of all keys. If multiple keys map to the same integer, then
-    only one of them can be in the table at a time. Any operation that supplies a key
-    whose corresponding integer is outside the allowed range for the table will cause an
+    any type, but table creation requires a [key_to_int] function, which will be used to
+    extract the integer of all keys. If multiple keys map to the same integer, then only
+    one of them can be in the table at a time. Any operation that supplies a key whose
+    corresponding integer is outside the allowed range for the table will cause an
     exception.
 
     A [Bounded_int_table] is implemented using two fixed-size arrays of size [num_keys],
@@ -16,8 +16,7 @@
     single element ([find], [mem], [add], [remove], [set]) take constant time, and perform
     one or two array operations. Operations that deal with all of the keys defined in the
     table ([data], [fold], [iter], [keys], [to_alist]) take time proportional to the
-    [length] of the table, not [num_keys].
-*)
+    [length] of the table, not [num_keys]. *)
 
 open! Core
 
@@ -27,11 +26,11 @@ type ('a, 'b) table = ('a, 'b) t
 include Invariant.S2 with type ('a, 'b) t := ('a, 'b) t
 
 (** Equality only requires the keys and values to be the same, not the bin or sexp
-    formatting or the integers the keys correspond to (see [key_to_int]).*)
+    formatting or the integers the keys correspond to (see [key_to_int]). *)
 include Equal.S2 with type ('a, 'b) t := ('a, 'b) t
 
-(** [create ~num_keys ~key_to_int] returns a table where the keys can map to 0
-    ... [num_keys] - 1, according to [key_to_int]. It is an error if [num_keys < 0].
+(** [create ~num_keys ~key_to_int] returns a table where the keys can map to 0 ...
+    [num_keys] - 1, according to [key_to_int]. It is an error if [num_keys < 0].
 
     [sexp_of_key], if supplied, will be used to display keys in error messages. *)
 val create