Remove Belt.Array.push (#122)

Author: davesnx

packages/Belt/src/Belt_Array.ml

@@ -518,10 +518,4 @@ let joinWithU a sep toString =
 let joinWith a sep toString = joinWithU a sep (fun x -> toString x)
 let initU n f = Stdlib.Array.init n f
 let init n f = initU n (fun i -> f i)
-
-let push arr i =
-  let len = length arr in
-  setUnsafe arr (len + 1) i
-[@@deprecated
-  "You should use `concat` instead. Since in JavaScript `Array.prototype.push` \
-   mutates the array reference, and it is not possible in native OCaml."]
+let push _arr _i = `Do_not_use_Array_push_in_native

packages/Belt/src/Belt_Array.mli

@@ -668,16 +668,10 @@ val truncateToLengthUnsafe : 'a t -> int -> 'a t
     let () = truncateToLengthUnsafe arr 3;;
     arr = [|"ant";"bee";"cat"|];;
   ]}
-
 *)
 
 val initU : int -> ((int -> 'a)[@bs]) -> 'a t
 val init : int -> (int -> 'a) -> 'a t
 
-(* external push : 'a t -> 'a -> unit = "push"
-   [@@send] *)
-val push : 'a t -> 'a -> unit
-(**
-  [arr->push(item)]
-  push element `item` into the array
-*)
+val push : 'a t -> 'a -> [ `Do_not_use_Array_push_in_native ]
+(** Using Belt.Array.push in native isn't a good idea, since OCaml's Array are fixed length and can't resize the same way as JavaScript arrays. *)

packages/Belt/test/benchmark.ml

@@ -0,0 +1,84 @@
+open Bechamel
+
+(* From our function [make_list], we make an indexed (by [args]) test. It's a list
+   of tests which are applied with [args] such as:
+
+    {[
+      let test =
+        [ make_list 0
+        ; make_list 10
+        ; make_list 100
+        ; make_list 400
+        ; make_list 1000 ]
+    ]} *)
+let static_array = [| 33 |]
+
+let test =
+  Test.make_indexed ~name:"Belt.Array.push" ~fmt:"%s %d"
+    ~args:[ 0; 100; 500; 1000; 10000 ] (fun words ->
+      Staged.stage @@ fun () -> Belt.Array.push static_array words)
+
+(* From our test, we can start to benchmark it!
+
+   A benchmark is a /run/ of your test multiple times. From results given by
+   [Benchmark.all], an analyse is needed to infer measures of one call of your
+   test.
+
+   [Bechamel] asks 3 things:
+   - what you want to record (see [instances])
+   - how you want to analyse (see [ols])
+   - how you want to benchmark your test (see [cfg])
+
+   The core of [Bechamel] (see [Bechamel.Toolkit]) has some possible measures
+   such as the [monotonic-clock] to see time performances.
+
+   The analyse can be OLS (Ordinary Least Square) or RANSAC. In this example, we
+   use only one.
+
+   Finally, to launch the benchmark, we need some others details such as:
+   - should we stabilise the GC?
+   - how many /run/ you want
+   - the maximum of time allowed by the benchmark
+   - etc.
+
+   [raw_results] is what the benchmark produced. [results] is what the analyse
+   can infer. The first one is used to show graphs or to let the user (with
+   [Measurement_raw]) to infer something else than what [ols] did. The second is
+   mostly what you want: a synthesis of /samples/. *)
+
+let benchmark () =
+  let ols =
+    Analyze.ols ~bootstrap:0 ~r_square:true ~predictors:Measure.[| run |]
+  in
+  let instances =
+    Toolkit.Instance.[ minor_allocated; major_allocated; monotonic_clock ]
+  in
+  let cfg =
+    Benchmark.cfg ~limit:2000 ~quota:(Time.second 0.5) ~kde:(Some 1000) ()
+  in
+  let raw_results = Benchmark.all cfg instances test in
+  let results =
+    List.map (fun instance -> Analyze.all ols instance raw_results) instances
+  in
+  let results = Analyze.merge ols instances results in
+  (results, raw_results)
+
+let () =
+  List.iter
+    (fun v -> Bechamel_notty.Unit.add v (Measure.unit v))
+    Toolkit.Instance.[ minor_allocated; major_allocated; monotonic_clock ]
+
+let img (window, results) =
+  Bechamel_notty.Multiple.image_of_ols_results ~rect:window
+    ~predictor:Measure.run results
+
+open Notty_unix
+
+let () =
+  let window =
+    match winsize Unix.stdout with
+    | Some (w, h) -> { Bechamel_notty.w; h }
+    | None -> { Bechamel_notty.w = 80; h = 1 }
+  in
+  let results, _ = benchmark () in
+  img (window, results) |> eol |> output_image

packages/Belt/test/dune

@@ -1,4 +1,10 @@
 (test
  (name test)
- (modules :standard)
+ (modules test)
  (libraries alcotest fmt belt js))
+
+; (executable
+; (name benchmark)
+; (modules benchmark)
+; (public_name belt_benchmark)
+; (libraries belt bechamel-notty bechamel unix notty.unix))

packages/melange.ppx/regex.ml

@@ -1,26 +1,14 @@
 open Ppxlib
 module Builder = Ast_builder.Default
 
-let compile_regex ~flags str =
-  match Quickjs.RegExp.compile str flags with
-  | regex -> Ok regex
-  | exception Invalid_argument msg -> Error msg
-  | exception _ -> Error "unknown error while compiling regex"
-
 let parse_re str =
   try
     let _ = Str.search_forward (Str.regexp "/\\(.*\\)/\\(.*\\)") str 0 in
     let first = Str.matched_group 1 str in
     let second = Str.matched_group 2 str in
     match String.length second with
-    | 0 -> (
-        match compile_regex ~flags:"" first with
-        | Ok _regex -> Ok (first, None)
-        | Error msg -> Error msg)
-    | _ -> (
-        match compile_regex ~flags:second first with
-        | Ok _regex -> Ok (first, Some second)
-        | Error msg -> Error msg)
+    | 0 -> Ok (first, None)
+    | _ -> Ok (first, Some second)
   with Not_found -> Error "invalid regex"
 
 let extractor = Ast_pattern.(__')