added hazel

Author: green726

Makefile

@@ -19,7 +19,7 @@ init:
 	@echo "" > src/core/material/precompiled/walk_r_no_filter_map.txt
 	dune build @src/fmt --auto-promote || true
 	dune build src --profile dev
-	./_build/default/src/minijs/precompile.exe
+	./_build/default/src/hazel/precompile.exe
 	mv enter_l_map.txt src/core/material/precompiled
 	mv enter_r_map.txt src/core/material/precompiled
 	mv nts.txt src/core/material/precompiled

src/core/editor/Modify.re

@@ -600,18 +600,18 @@ let apply_remold = (changes, ctx) => {
   let+ changed = apply_changes(changes, ctx);
   () => {
     open Options.Syntax;
-    let* ((ctx, fill), expanded, restrict_obligs) = changed();
-    P.log("--- Modify.apply_remold/changed");
-    P.sexp("ctx", Ctx.sexp_of_t(ctx));
-    P.show("fill", Cell.show(fill));
-    P.show("expanded", string_of_bool(expanded));
-    P.show("restrict_obligs", string_of_bool(restrict_obligs));
+    let* ((ctx, fill), _expanded, _restrict_obligs) = changed();
+    // P.log("--- Modify.apply_remold/changed");
+    // P.sexp("ctx", Ctx.sexp_of_t(ctx));
+    // P.show("fill", Cell.show(fill));
+    // P.show("expanded", string_of_bool(expanded));
+    // P.show("restrict_obligs", string_of_bool(restrict_obligs));
     let (remolded, ctx) = remold(~fill, ctx);
     // P.log("--- Modify.apply_remold/remolded");
     // P.show("remolded", Grouted.show(remolded));
     // P.show("ctx", Ctx.show(ctx));
-    P.show("effects", Fmt.(to_to_string(list(Effects.pp), Effects.log^)));
-    P.show("delta", Oblig.Delta.show(Oblig.Delta.of_effects(Effects.log^)));
+    // P.show("effects", Fmt.(to_to_string(list(Effects.pp), Effects.log^)));
+    // P.show("delta", Oblig.Delta.show(Oblig.Delta.of_effects(Effects.log^)));
     // !expanded
     // && restrict_obligs
     // && Oblig.Delta.(not_hole(of_effects(Effects.log^)))

src/core/parser/Grouter.re

@@ -110,8 +110,14 @@ let bake_stances = stances => stances |> List.map(bake_stance) |> Option.some;
 
 let rec degrout = (c: Cell.t): Cells.t =>
   switch (Cell.get(c)) {
+  //open the cell
   | Some(M(l, w, r)) when Option.is_some(Wald.is_grout(w)) =>
+    P.log("degrout hit some case");
+    //pull the inner cells out ("base")
     let W((toks, cells)) = w;
+    P.show("l: ", Cell.show(l));
+    P.show("w: ", Wald.show(w));
+    P.show("r: ", Cell.show(r));
     List.iter(Effects.remove, toks);
     // we wish to maximally stabilize grout positioning, ie grout that is removed
     // in this pass, if reinserted, should be reinserted in the same position.
@@ -123,9 +129,12 @@ let rec degrout = (c: Cell.t): Cells.t =>
     let cells_l =
       switch (cells) {
       | [hd, ...tl] when Cell.Space.is_space(l) =>
+        //mark_degrouted says "a grout once was here"
         let l = Cell.mark_degrouted(l, ~side=R);
+        P.show("degrout cells_l & pad without squash", Cell.show(l));
         [Cell.pad(~squash=false, ~l, hd), ...tl];
       | [] when Cell.Space.is_space(l) =>
+        P.show("degrout cells_l", Cell.show(l));
         let l = Cell.mark_degrouted(l, ~side=R);
         [l];
       | _ => [l, ...cells]
@@ -134,9 +143,11 @@ let rec degrout = (c: Cell.t): Cells.t =>
       switch (Lists.Framed.ft(cells_l)) {
       | Some((pre, ft)) when Cell.Space.is_space(r) =>
         let r = Cell.mark_degrouted(~side=L, r);
+        P.show("degrout cells_r & pad without squash", Cell.show(l));
         Lists.Framed.put_ft(pre, Cell.pad(~squash=false, ft, ~r));
       | None when Cell.Space.is_space(r) =>
         let r = Cell.mark_degrouted(~side=L, r);
+        P.show("degrout cells_r", Cell.show(l));
         [r];
       | _ => cells_l @ [r]
       };
@@ -158,23 +169,40 @@ let fill_default =
       ),
     );
 
+/*
+    slot = swing = "tower" of nonterminals (modeled via chain) - tower is a partial (left spine) "derivation" through non-terminal symbols to other non terminals
+    bot is the most important nt as it is the fill target; everything above is context
+   swing example:
+     _ + n * _
+     walk (+ -> *) L->R
+     swing b/w: R(+), L(*)
+     filling in the swing would be filling the left arg of times L(*)
+
+   top and bot essentially provide L/R bounds on the fill of interest
+
+
+    takes in a particular bin of fills (if 4 fills, 3 slots, 4 fills will be partitioned into 3 bins)
+ */
+
 // assumes cs already squashed sans padding
 let fill_swing = (cs: Cells.t, sw: Walk.Swing.t, ~from: Dir.t) => {
   let cs = Dir.pick(from, (List.rev, Fun.id), cs);
-  if (dbg^) {
-    P.log("--- Grouter.fill_swing");
-    P.show("from", Dir.show(from));
-    P.show("sw", Walk.Swing.show(sw));
-    P.show("cs", Cells.show(cs));
-  };
+  // if (dbg^) {
+  // P.log("--- Grouter.fill_swing");
+  // P.show("from", Dir.show(from));
+  // P.show("sw", Walk.Swing.show(sw));
+  // P.show("cs", Cells.show(cs));
+  // };
   let (bot, top) = Walk.Swing.(bot(sw), top(sw));
   switch (bot) {
   | Space(nt) =>
-    if (dbg^) {
-      P.log("--- Grouter.fill_swing/Space");
-      P.show("nt", Space.NT.show(nt));
-      P.show("cs", Cells.show(cs));
-    };
+    // if (dbg^) {
+    // P.log("--- Grouter.fill_swing/Space");
+    // P.show("from", Dir.show(from));
+    // P.show("sw", Walk.Swing.show(sw));
+    // P.show("nt", Space.NT.show(nt));
+    // P.show("cs", Cells.show(cs));
+    // };
     let squashed = Cells.squash(cs);
     if (dbg^) {
       P.show("squashed", Cells.show(squashed));
@@ -209,8 +237,11 @@ let fill_swing = (cs: Cells.t, sw: Walk.Swing.t, ~from: Dir.t) => {
     open Options.Syntax;
     let (nt_l, nt_r) =
       Walk.Swing.is_eq(sw) ? (bot, bot) : Dir.order(from, (top, bot));
+    //check that fills are properly precedence bounded by swing nts
     let+ has_pre = Cells.are_bounded(cs, nt_l, ~from=L)
     and+ has_pos = Cells.are_bounded(cs, nt_r, ~from=R);
+    //handles breadcrumbs from degrouting to retain grout positioning
+    //NOTE: split padding is a possible candidate for newline bug fix
     switch (Cells.split_padding(cs)) {
     | (l, cs, r) when List.for_all(Cell.Space.is_space, cs) =>
       if (dbg^) {
@@ -235,6 +266,8 @@ let fill_swing = (cs: Cells.t, sw: Walk.Swing.t, ~from: Dir.t) => {
         P.show("cs", Cells.show(cs));
         P.show("r", Cell.show(r));
       };
+      //cells is list of children cells for target grout form
+      //cons/scnoc here effectively add l/r as children of prefix/postfix grout
       let cells =
         cs
         |> (has_pre ? List.cons(l) : Lists.map_hd(Cell.pad(~l)))
@@ -249,6 +282,8 @@ let fill_swing = (cs: Cells.t, sw: Walk.Swing.t, ~from: Dir.t) => {
           has_pos ? [Effects.insert(pos(s))] : [],
         ]
         |> List.concat;
+      //chain is the content of the cell that we will be returning
+      //essentially a meld represented with Chain.t
       let chain = Chain.mk(cells, toks);
       switch (Chain.unlink(chain)) {
       | Error(c) =>
@@ -267,6 +302,20 @@ let fill_swing = (cs: Cells.t, sw: Walk.Swing.t, ~from: Dir.t) => {
   };
 };
 
+/*degrout explain:
+      if fill: 1 > < 2
+      then degrout would separate this into two separate fills
+      [1, 2] with no infix grout
+
+      if fill: \n <> (newline is left child of hole - whitespace has max prec)
+          then degrout produces \n (single newline cell)
+
+
+      degrout functionally strips away top level grout to re-create from a clean(ish) slate to verify minimality
+
+      if same grout is reinserted to fill, it must be in the same pos
+  */
+
 let fill_swings =
     (~repair, ~from, cells: list(Cell.t), swings: list(Walk.Swing.t)) => {
   if (dbg^) {
@@ -278,7 +327,7 @@ let fill_swings =
   cells
   |> Dir.pick(from, (List.rev, Fun.id))
   |> (repair ? List.concat_map(degrout) : Fun.id)
-  // |> (dbg^ ? P.oshow("degrouted", Cells.show) : Fun.id)
+  |> (true ? P.oshow("degrouted", Cells.show) : Fun.id)
   |> Dir.pick(from, (List.rev, Fun.id))
   |> Lists.split_bins(List.length(swings))
   |> Oblig.Delta.minimize(~to_zero=!repair, c_bins =>
@@ -303,13 +352,14 @@ let fill = (~repair, ~from, cs, (swings, stances): Walk.t) => {
 // pick a walk from ws that best accommodates the cells in cs, ie minimizes
 // obligation delta. the given cells are expected to be oriented the same way as the
 // given walks according to from.
+//cs should be a singleton cell
 let pick = (~repair=false, ~from: Dir.t, cs: list(Cell.t), ws: list(Walk.t)) => {
   // if (dbg^) {
-  //   P.log("--- Grouter.pick");
-  //   P.show("from", Dir.show(from));
-  //   P.show("cs", Cells.show(cs));
-  //   P.log("ws");
-  //   ws |> List.iter(w => P.show("w", Walk.show(w)));
+  // P.log("--- Grouter.pick");
+  // P.show("from", Dir.show(from));
+  // P.show("cs", Cells.show(cs));
+  // P.log("ws");
+  // ws |> List.iter(w => P.show("w", Walk.show(w)));
   // };
   Oblig.Delta.minimize(
     ~to_zero=!repair,

src/core/parser/Melder.re

@@ -108,6 +108,21 @@ let combine_cells =
   };
 };
 
+//let x = 2 + _ >in< 1
+//insert an "in" after 1
+/*
+ onto: let x = 2 + _ >in<
+ fill: 1
+ t: in
+
+
+ onto: let x =
+ fill: combine_cells(2 + _, 1) -> 2 + 1
+ t: in
+
+ ret: (Grouted(Chain((2 + 1, grammar swing over let definition))), onto: let x = )
+ */
+
 let connect_eq =
     (~repair=?, ~onto as d: Dir.t, onto: Terr.t, ~fill=Cell.empty, t: Token.t)
     : option((Grouted.t, Terr.t)) => {

src/core/structure/Cell.re

@@ -280,17 +280,22 @@ module Space = {
     };
 
   // returns split-off cell first (regardless of side), rest of cell second
+  // if i find a degrout mark within the space cell, split the cell into two at that point
   let split = (~side as d: Dir.t, c: t) => {
     open Options.Syntax;
     assert(is_space(c));
+    //g = general get
+    //calling get on a space cell (spaces separated by empty cells with potential metadata ie degrout)
     let* m = g(c);
     let (cs, ts) = m |> Dir.pick(d, (Fun.id, Meld.rev)) |> Meld.to_chain;
+    //traverses cells and searches for 1st cell with degrout mark
     let (cs_d, cs_b) =
       cs
       |> Lists.split_while(~f=(c: t) => Path.Map.is_empty(c.marks.degrouted));
     switch (cs_d, cs_b) {
     | (_, []) => None
     | ([], [b_hd, ...b_tl]) =>
+      //ensuring no cursor duplication in cells with degrouted mark
       let b_hd_dup = {
         ...b_hd,
         marks: {