v0.18~preview.130.76+222

Author: public-release

base.opam

@@ -12,6 +12,7 @@ build: [
 depends: [
   "ocaml" {>= "5.1.0"}
   "basement"
+  "capsule0"
   "ocaml_intrinsics_kernel"
   "ppx_array_base"
   "ppx_base"

generate/generate_pow_overflow_bounds.ml

@@ -1,9 +1,7 @@
-(* NB: This needs to be pure OCaml (no Base!), since we need this in order to build
-   Base. *)
+(* NB: This needs to be pure OCaml (no Base!), since we need this in order to build Base. *)
 
 (* This module generates lookup tables to detect integer overflow when calculating integer
-   exponents.  At index [e], [table.[e]^e] will not overflow, but [(table[e] + 1)^e]
-   will. *)
+   exponents. At index [e], [table.[e]^e] will not overflow, but [(table[e] + 1)^e] will. *)
 module Z = Zarith.Z
 
 type mode =

lint/ppx_base_lint.ml

@@ -148,7 +148,7 @@ let check current_module =
                   (remove_loc#attributes new_attrs))
           then (
             (* Remove attributes written by the user that correspond to attributes in the
-             expansion *)
+               expansion *)
             List.iter attrs ~f:(fun a ->
               if is_part_of_expansion a
               then Driver.register_correction ~loc:a.attr_loc ~repl:"");

shadow-stdlib/gen/gen.ml

@@ -1,10 +1,10 @@
 open StdLabels
 
 let () =
-  (* -permissive indicates that we should tolerate additions to stdlib.
-     It's [true] in public-release so that new versions of the stdlib can be compatible
-     with base, but it should be [false] internally so that we remember to
-     consider implementing the equivalents in base. *)
+  (* -permissive indicates that we should tolerate additions to stdlib. It's [true] in
+     public-release so that new versions of the stdlib can be compatible with base, but it
+     should be [false] internally so that we remember to consider implementing the
+     equivalents in base. *)
   let permissive, cmi_fn, oc =
     match Sys.argv with
     | [| _; "-caml-cmi"; cmi_fn; "-o"; fn |] -> false, cmi_fn, open_out fn

src/array.ml

@@ -16,10 +16,11 @@ type ('a : any mod separable) t = 'a array
 type%template ('a : k) t = 'a array [@@kind k = (base_non_value, immediate, immediate64)]
 
 [%%rederive.portable
-  type nonrec 'a t = 'a array [@@deriving globalize, sexp ~stackify, sexp_grammar]]
+  type nonrec ('a : value_or_null mod separable) t = 'a array
+  [@@deriving globalize, sexp ~stackify, sexp_grammar]]
 
 (* This module implements a new in-place, constant heap sorting algorithm to replace the
-   one used by the standard libraries.  Its only purpose is to be faster (hopefully
+   one used by the standard libraries. Its only purpose is to be faster (hopefully
    strictly faster) than the base sort and stable_sort.
 
    At a high level the algorithm is:
@@ -39,11 +40,10 @@ type%template ('a : k) t = 'a array [@@kind k = (base_non_value, immediate, imme
      behavior
 
    See the following for more information:
-   - "Dual-Pivot Quicksort" by Vladimir Yaroslavskiy.
-     Available at
+   - "Dual-Pivot Quicksort" by Vladimir Yaroslavskiy. Available at
      http://www.kriche.com.ar/root/programming/spaceTimeComplexity/DualPivotQuicksort.pdf
-   - "Quicksort is Optimal" by Sedgewick and Bentley.
-     Slides at http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf
+   - "Quicksort is Optimal" by Sedgewick and Bentley. Slides at
+     http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf
    - http://www.sorting-algorithms.com/quick-sort-3-way *)
 
 module%template.portable
@@ -75,9 +75,9 @@ struct
   (* http://en.wikipedia.org/wiki/Insertion_sort *)
   module Insertion_sort : Sort = struct
     (* loop invariants:
-       1.  the subarray arr[left .. i-1] is sorted
-       2.  the subarray arr[i+1 .. pos] is sorted and contains only elements > v
-       3.  arr[i] may be thought of as containing v
+       1. the subarray arr[left .. i-1] is sorted
+       2. the subarray arr[i+1 .. pos] is sorted and contains only elements > v
+       3. arr[i] may be thought of as containing v
     *)
     let rec insert_loop arr ~left ~compare i v =
       let i_next = i - 1 in
@@ -89,8 +89,7 @@ struct
     ;;
 
     let sort arr ~compare ~left ~right =
-      (* loop invariant:
-         [arr] is sorted from [left] to [pos - 1], inclusive *)
+      (* loop invariant: [arr] is sorted from [left] to [pos - 1], inclusive *)
       for pos = left + 1 to right do
         let v = get arr pos in
         let final_pos = insert_loop arr ~left ~compare pos v in
@@ -101,8 +100,7 @@ struct
 
   (* http://en.wikipedia.org/wiki/Heapsort *)
   module Heap_sort : Sort = struct
-    (* loop invariant:
-       root's children are both either roots of max-heaps or > right *)
+    (* loop invariant: root's children are both either roots of max-heaps or > right *)
     let rec heapify arr ~compare root ~left ~right =
       let relative_root = root - left in
       let left_child = (2 * relative_root) + left + 1 in
@@ -124,7 +122,7 @@ struct
     ;;
 
     let build_heap arr ~compare ~left ~right =
-      (* Elements in the second half of the array are already heaps of size 1.  We move
+      (* Elements in the second half of the array are already heaps of size 1. We move
          through the first half of the array from back to front examining the element at
          hand, and the left and right children, fixing the heap property as we go. *)
       for i = (left + right) / 2 downto left do
@@ -135,9 +133,9 @@ struct
     let sort arr ~compare ~left ~right =
       build_heap arr ~compare ~left ~right;
       (* loop invariants:
-         1.  the subarray arr[left ... i] is a max-heap H
-         2.  the subarray arr[i+1 ... right] is sorted (call it S)
-         3.  every element of H is less than every element of S *)
+         1. the subarray arr[left ... i] is a max-heap H
+         2. the subarray arr[i+1 ... right] is sorted (call it S)
+         3. every element of H is less than every element of S *)
       for i = right downto left + 1 do
         swap arr left i;
         heapify arr ~compare left ~left ~right:(i - 1)
@@ -175,7 +173,7 @@ struct
             4-----o--------o--o--|-----o--4
                   |              |     |
             5-----o--------------o-----o--5
-          v} *)
+         v} *)
       compare_and_swap m1 m2;
       compare_and_swap m4 m5;
       compare_and_swap m1 m3;
@@ -188,13 +186,11 @@ struct
     ;;
 
     (* choose pivots for the array by sorting 5 elements and examining the center three
-       elements.  The goal is to choose two pivots that will either:
-       - break the range up into 3 even partitions
-         or
-       - eliminate a commonly appearing element by sorting it into the center partition
-         by itself
-         To this end we look at the center 3 elements of the 5 and return pairs of equal
-         elements or the widest range *)
+       elements. The goal is to choose two pivots that will either:
+       - break the range up into 3 even partitions or
+       - eliminate a commonly appearing element by sorting it into the center partition by
+         itself To this end we look at the center 3 elements of the 5 and return pairs of
+         equal elements or the widest range *)
     let choose_pivots arr ~(local_ compare : _ -> _ -> _) ~left ~right =
       let sixth = (right - left) / 6 in
       let m1 = left + sixth in
@@ -215,7 +211,7 @@ struct
 
     let dual_pivot_partition arr ~(local_ compare : _ -> _ -> _) ~left ~right =
       let #(pivot1, pivot2, pivots_equal) = choose_pivots arr ~compare ~left ~right in
-      (* loop invariants:
+      (*=loop invariants:
          1.  left <= l < r <= right
          2.  l <= p <= r
          3.  l <= x < p     implies arr[x] >= pivot1
@@ -233,7 +229,7 @@ struct
             loop (l + 1) (p + 1) r)
           else if compare pv pivot2 > 0
           then (
-            (* loop invariants:  same as those of the outer loop *)
+            (* loop invariants: same as those of the outer loop *)
             let rec scan_backwards r =
               if r > p && compare (get arr r) pivot2 > 0
               then scan_backwards (r - 1)
@@ -251,7 +247,7 @@ struct
     let rec intro_sort arr ~max_depth ~compare ~left ~right =
       let len = right - left + 1 in
       (* This takes care of some edge cases, such as left > right or very short arrays,
-         since Insertion_sort.sort handles these cases properly.  Thus we don't need to
+         since Insertion_sort.sort handles these cases properly. Thus we don't need to
          make sure that left and right are valid in recursive calls. *)
       if len <= 32
       then Insertion_sort.sort arr ~compare ~left ~right
@@ -691,8 +687,7 @@ let check_length2_exn name t1 t2 =
   if n1 <> n2 then raise_length_mismatch name n1 n2
 ;;
 
-(* [of_list_map] and [of_list_rev_map] are based on functions from the OCaml
-   distribution. *)
+(* [of_list_map] and [of_list_rev_map] are based on functions from the OCaml distribution. *)
 
 let of_list_map (xs : (_ List.Constructors.t[@kind k1])) ~f =
   match xs with
@@ -1062,8 +1057,8 @@ let sorted_copy t ~compare =
 let last_exn t = t.(length t - 1)
 let last = last_exn
 
-(* Convert to a sequence but does not attempt to protect against modification
-   in the array. *)
+(* Convert to a sequence but does not attempt to protect against modification in the
+   array. *)
 let to_sequence_mutable t =
   Sequence.unfold_step ~init:0 ~f:(fun i ->
     if i >= length t

src/array0.ml

@@ -1,12 +1,12 @@
 (* [Array0] defines array functions that are primitives or can be simply defined in terms
-   of [Stdlib.Array].  [Array0] is intended to completely express the part of [Stdlib.Array]
-   that [Base] uses -- no other file in Base other than array0.ml should use [Stdlib.Array].
-   [Array0] has few dependencies, and so is available early in Base's build order.  All
-   Base files that need to use arrays and come before [Base.Array] in build order should
-   do [module Array = Array0].  This includes uses of subscript syntax ([x.(i)], [x.(i) <-
-   e]), which the OCaml parser desugars into calls to [Array.get] and [Array.set].
-   Defining [module Array = Array0] is also necessary because it prevents ocamldep from
-   mistakenly causing a file to depend on [Base.Array]. *)
+   of [Stdlib.Array]. [Array0] is intended to completely express the part of
+   [Stdlib.Array] that [Base] uses -- no other file in Base other than array0.ml should
+   use [Stdlib.Array]. [Array0] has few dependencies, and so is available early in Base's
+   build order. All Base files that need to use arrays and come before [Base.Array] in
+   build order should do [module Array = Array0]. This includes uses of subscript syntax
+   ([x.(i)], [x.(i) <- e]), which the OCaml parser desugars into calls to [Array.get] and
+   [Array.set]. Defining [module Array = Array0] is also necessary because it prevents
+   ocamldep from mistakenly causing a file to depend on [Base.Array]. *)
 
 [@@@warning "-incompatible-with-upstream"]
 

src/array_intf.ml

@@ -26,14 +26,15 @@ module Definitions = struct
       type 'a t := 'a t
       type 'a t = 'a t [@@kind base_non_value, immediate, immediate64]]
 
-    [@@@kind k = base_with_imm]
+    [@@@kind k = base_or_null_with_imm]
 
     [%%rederive:
-      type nonrec ('a : k) t = 'a t
+      type nonrec ('a : k mod separable) t = 'a t
       [@@kind k]
       [@@deriving compare ~localize, equal ~localize, sexp ~stackify, globalize]]]
 
-    [%%rederive: type nonrec 'a t = 'a t [@@deriving sexp_grammar]]
+    [%%rederive:
+      type nonrec ('a : value_or_null mod separable) t = 'a t [@@deriving sexp_grammar]]
 
     include Indexed_container.S1_with_creators with type 'a t := 'a t
     include Invariant.S1 with type 'a t := 'a t
@@ -147,7 +148,9 @@ module Definitions = struct
     val create_float_uninitialized : len:int -> float t
 
     (** [init n ~f] creates an array of length [n] with index [i] set to [f i]. *)
-    val%template init : int -> f:(int -> 'a) @ local -> 'a array @ m
+    val%template init
+      : ('a : value_or_null mod separable).
+      int -> f:(int -> 'a) @ local -> 'a array @ m
     [@@alloc __ @ m = (heap_global, stack_local)]
 
     (** [Array.make_matrix dimx dimy e] returns a two-dimensional array (an array of
@@ -470,7 +473,7 @@ module type Array = sig @@ portable
 
   (*_ See the Jane Street Style Guide for an explanation of [Private] submodules:
 
-    https://opensource.janestreet.com/standards/#private-submodules *)
+      https://opensource.janestreet.com/standards/#private-submodules *)
   module Private : sig
     module%template [@kind k = value_with_imm] Sort : sig
       module type Sort = sig @@ portable

src/avltree.ml

@@ -83,15 +83,11 @@ let invariant compare =
 
 let invariant t ~compare = (invariant [@kind k v]) compare t
 
-(* In the following comments,
-   't is balanced' means that 'invariant t' does not
-   raise an exception.  This implies of course that each node's height field is
-   correct.
-   't is balanceable' means that height of the left and right subtrees of t
-   differ by at most 3. *)
-
-(* @pre: left and right subtrees have correct heights
-   @post: output has the correct height *)
+(* In the following comments, 't is balanced' means that 'invariant t' does not raise an
+   exception. This implies of course that each node's height field is correct. 't is
+   balanceable' means that height of the left and right subtrees of t differ by at most 3. *)
+
+(* @pre: left and right subtrees have correct heights @post: output has the correct height *)
 let update_height = function
   | Node ({ left; key = _; value = _; height = old_height; right } as x) ->
     let new_height =
@@ -101,26 +97,23 @@ let update_height = function
   | Empty | Leaf _ -> assert false
 ;;
 
-(* @pre: left and right subtrees are balanced
-   @pre: tree is balanceable
-   @post: output is balanced (in particular, height is correct) *)
+(* @pre: left and right subtrees are balanced @pre: tree is balanceable @post: output is
+   balanced (in particular, height is correct) *)
 let balance tree =
   match tree with
   | Empty | Leaf _ -> tree
   | Node ({ left; key = _; value = _; height = _; right } as root_node) ->
     let hl = (height [@kind k v]) left
     and hr = (height [@kind k v]) right in
-    (* + 2 is critically important, lowering it to 1 will break the Leaf
-       assumptions in the code below, and will force us to promote leaf nodes in
-       the balance routine. It's also faster, since it will balance less often.
-       Note that the following code is delicate.  The update_height calls must
-       occur in the correct order, since update_height assumes its children have
-       the correct heights.  *)
+    (* + 2 is critically important, lowering it to 1 will break the Leaf assumptions in
+         the code below, and will force us to promote leaf nodes in the balance routine.
+         It's also faster, since it will balance less often. Note that the following code
+         is delicate. The update_height calls must occur in the correct order, since
+         update_height assumes its children have the correct heights. *)
     if hl > hr + 2
     then (
       match left with
-      (* It cannot be a leaf, because even if right is empty, a leaf
-         is only height 1 *)
+      (* It cannot be a leaf, because even if right is empty, a leaf is only height 1 *)
       | Empty | Leaf _ -> assert false
       | Node
           ({ left = left_node_left
@@ -137,8 +130,8 @@ let balance tree =
           (update_height [@kind k v]) left;
           left)
         else (
-          (* if right is a leaf, then left must be empty. That means
-             height is 2. Even if hr is empty we still can't get here. *)
+          (* if right is a leaf, then left must be empty. That means height is 2. Even if
+             hr is empty we still can't get here. *)
           match left_node_right with
           | Empty | Leaf _ -> assert false
           | Node
@@ -191,9 +184,8 @@ let balance tree =
       tree)
 ;;
 
-(* @pre: t is balanced.
-   @post: result is balanced, with new node inserted
-   @post: !added = true iff the shape of the input tree changed.  *)
+(* @pre: t is balanced. @post: result is balanced, with new node inserted @post: !added =
+   true iff the shape of the input tree changed. *)
 
 let rec add t ~replace ~compare ~added ~key:k ~data:v =
   match t with
@@ -202,9 +194,8 @@ let rec add t ~replace ~compare ~added ~key:k ~data:v =
     Leaf { key = k; value = v }
   | Leaf ({ key = k'; value = _ } as r) ->
     let c = compare k' k in
-    (* This compare is reversed on purpose, we are pretending
-       that the leaf was just inserted instead of the other way
-       round, that way we only allocate one node. *)
+    (* This compare is reversed on purpose, we are pretending that the leaf was just
+       inserted instead of the other way round, that way we only allocate one node. *)
     if c = 0
     then (
       added := false;

src/base.ml

@@ -24,8 +24,8 @@
       structures (arrays, lists, strings).
     - [Result], [Error], and [Or_error], supporting the or-error pattern. *)
 
-(*_ We hide this from the web docs because the line wrapping is bad, making it
-  pretty much inscrutable. *)
+(*_ We hide this from the web docs because the line wrapping is bad, making it pretty much
+    inscrutable. *)
 (**/**)
 
 (* The intent is to shadow all of INRIA's standard library.  Modules below would cause
@@ -201,7 +201,7 @@ module Export = struct
 
   (* [deriving hash] is missing for [array] and [ref] since these types are mutable. *)
   [%%rederive.portable
-    type 'a array = 'a Array.t
+    type ('a : value_or_null mod separable) array = 'a Array.t
     [@@deriving
       compare ~localize, equal ~localize, globalize, sexp ~stackify, sexp_grammar]]
 
@@ -406,8 +406,8 @@ module Export = struct
 
   external force : ('a Lazy.t[@local_opt]) -> 'a @@ portable = "%lazy_force"
 
-  (* Export ['a or_null] with constructors [Null] and [This] whenever Base is opened,
-     so uses of those identifiers work in both upstream OCaml and OxCaml. *)
+  (* Export ['a or_null] with constructors [Null] and [This] whenever Base is opened, so
+     uses of those identifiers work in both upstream OCaml and OxCaml. *)
 
   type 'a or_null = 'a Or_null.t
   [@@or_null_reexport]
@@ -423,8 +423,8 @@ include Modes.Export (** @inline *)
 exception Not_found_s = Not_found_s
 
 (* We perform these side effects here because we want them to run for any code that uses
-   [Base].  If this were in another module in [Base] that was not used in some program,
-   then the side effects might not be run in that program.  This will run as long as the
+   [Base]. If this were in another module in [Base] that was not used in some program,
+   then the side effects might not be run in that program. This will run as long as the
    program refers to at least one value directly in [Base]; referring to values in
    [Base.Bool], for example, is not sufficient. *)
 let () = Backtrace.initialize_module ()