ocaml: phase 5.1 bigint_add.ml baseline (digit-list bignum add, 1+18+9 = 28)

Recursive 4-arm match on (a, b) tuples threading a carry:

  match (a, b) with
  | ([], []) -> if carry = 0 then [] else [carry]
  | (x :: xs, []) -> (s mod 10) :: aux xs [] (s / 10)   where s = x + carry
  | ([], y :: ys) -> ...
  | (x :: xs, y :: ys) -> ...                           where s = x + y + carry

Little-endian digit lists. Three tests:

  [9;9;9] + [1]                 = [0;0;0;1]      (=1000, digit sum 1)
  [5;6;7] + [8;9;1]             = [3;6;9]        (=963, digit sum 18)
  [9;9;9;9;9;9;9;9] + [1]       length 9         (carry propagates 8x)

Sum = 1 + 18 + 9 = 28.

Exercises tuple-pattern match on nested list-cons with the integer
arithmetic and carry-threading idiom typical of multi-precision
implementations.

52 baseline programs total.

lib/ocaml/baseline/bigint_add.ml

@@ -0,0 +1,24 @@
+let bigint_add a b =
+  let rec aux a b carry =
+    match (a, b) with
+    | ([], []) -> if carry = 0 then [] else [carry]
+    | (x :: xs, []) ->
+      let s = x + carry in
+      (s mod 10) :: aux xs [] (s / 10)
+    | ([], y :: ys) ->
+      let s = y + carry in
+      (s mod 10) :: aux [] ys (s / 10)
+    | (x :: xs, y :: ys) ->
+      let s = x + y + carry in
+      (s mod 10) :: aux xs ys (s / 10)
+  in
+  aux a b 0
+
+;;
+
+let r1 = bigint_add [9;9;9] [1] in
+let r2 = bigint_add [5;6;7] [8;9;1] in
+let r3 = bigint_add [9;9;9;9;9;9;9;9] [1] in
+List.fold_left (+) 0 r1
+  + List.fold_left (+) 0 r2
+  + List.length r3

lib/ocaml/baseline/expected.json

@@ -2,6 +2,7 @@
   "ackermann.ml": 125,
   "anagrams.ml": 3,
   "bag.ml": 3,
+  "bigint_add.ml": 28,
   "bits.ml": 21,
   "balance.ml": 3,
   "bfs.ml": 6,

plans/ocaml-on-sx.md

@@ -407,6 +407,15 @@ _Newest first._
   binary search tree (`type 'a tree = Leaf | Node of 'a * 'a tree *
   'a tree`) with insert + in-order traversal. Tests parametric ADT,
   recursive match, List.append, List.fold_left.
+- 2026-05-09 Phase 5.1 — bigint_add.ml baseline (digit-list big-num
+  add, 28 = 1+18+9). Recursive 4-arm match on `(a, b)` tuples
+  threading a carry: `(x::xs, y::ys) -> (s mod 10) :: aux xs ys (s
+  / 10)`. Three test cases:
+    bigint_add [9;9;9] [1]    = [0;0;0;1]   (digit sum 1)
+    bigint_add [5;6;7] [8;9;1] = [3;6;9]    (digit sum 18, 765+198=963)
+    bigint_add [9;9;9;9;9;9;9;9] [1] length 9 (carry propagates 8 places)
+  Sum: 1 + 18 + 9 = 28. Exercises tuple-pattern match on nested
+  list-cons + integer arithmetic. 52 baseline programs total.
 - 2026-05-09 Phase 5.1 — expr_simp.ml baseline (symbolic expression
   simplifier, eval (simp e) = 22). Recursive ADT with three
   constructors (Num/Add/Mul). simp does bottom-up rewrite using