code folding

src/haz3lcore/Measured.re

@@ -267,7 +267,8 @@ let is_indented_map = (seg: Segment.t) => {
   go(seg);
 };
 
-let of_segment = (~old: t=empty, ~touched=Touched.empty, seg: Segment.t): t => {
+let of_segment =
+    (~old: t=empty, ~touched=Touched.empty, ~folded=[], seg: Segment.t): t => {
   let is_indented = is_indented_map(seg);
 
   // recursive across seg's bidelimited containers
@@ -276,6 +277,8 @@ let of_segment = (~old: t=empty, ~touched=Touched.empty, seg: Segment.t): t => {
             ~map,
             ~container_indent: abs_indent=0,
             ~origin=Point.zero,
+            ~compress=false,
+            ~outermost=false,
             seg: Segment.t,
           )
           : (Point.t, t) => {
@@ -319,9 +322,17 @@ let of_segment = (~old: t=empty, ~touched=Touched.empty, seg: Segment.t): t => {
              );
         (origin, map);
       | [hd, ...tl] =>
+        let fold = (origin: Point.t, last: Point.t) => {
+          let folded_last =
+            switch (tl) {
+            | [] when outermost => Point.{...origin, col: origin.col + 7}
+            | _ => origin
+            };
+          compress ? folded_last : last;
+        };
         let (contained_indent, origin, map) =
           switch (hd) {
-          | Secondary(w) when Secondary.is_linebreak(w) =>
+          | Secondary(w) when Secondary.is_linebreak(w) && !compress =>
             let row_indent = container_indent + contained_indent;
             let indent =
               if (Segment.sameline_secondary(tl)) {
@@ -352,37 +363,48 @@ let of_segment = (~old: t=empty, ~touched=Touched.empty, seg: Segment.t): t => {
           | Secondary(w) =>
             let wspace_length =
               Unicode.length(Secondary.get_string(w.content));
-            let last = {...origin, col: origin.col + wspace_length};
+            let last =
+              {...origin, col: origin.col + wspace_length} |> fold(origin);
             let map = map |> add_w(w, {origin, last});
             (contained_indent, last, map);
           | Grout(g) =>
-            let last = {...origin, col: origin.col + 1};
+            let last = {...origin, col: origin.col + 1} |> fold(origin);
             let map = map |> add_g(g, {origin, last});
             (contained_indent, last, map);
           | Tile(t) =>
             let token = List.nth(t.label);
-            let add_shard = (origin, shard, map) => {
+            let add_shard = (origin, shard, map, count) => {
               let last =
                 Point.{
                   ...origin,
                   col: origin.col + String.length(token(shard)),
-                };
+                }
+                |> fold(origin);
               let map = map |> add_s(t.id, shard, {origin, last});
-              (last, map);
+              (last, map, count + 1);
             };
-            let (last, map) =
+            let (last, map, _) =
               Aba.mk(t.shards, t.children)
               |> Aba.fold_left(
-                   shard => add_shard(origin, shard, map),
-                   ((origin, map), child, shard) => {
+                   shard => add_shard(origin, shard, map, 0),
+                   ((origin, map, count), child, shard) => {
+                     let in_folded = List.mem(t.id, folded) && count == 2;
                      let (child_last, child_map) =
                        go_nested(
                          ~map,
                          ~container_indent=container_indent + contained_indent,
                          ~origin,
+                         ~compress=compress || in_folded,
+                         ~outermost=in_folded && !compress,
                          child,
                        );
-                     add_shard(child_last, shard, child_map);
+                     //  let child_last =
+                     //    if (List.mem(t.id, folded_list) && count == 2) {
+                     //      Point.{...origin, col: origin.col + 7};
+                     //    } else {
+                     //      child_last;
+                     //    };
+                     add_shard(child_last, shard, child_map, count);
                    },
                  );
             (contained_indent, last, map);
@@ -407,27 +429,27 @@ let length = (seg: Segment.t, map: t): int =>
     last.last.col - first.origin.col;
   };
 
-let segment_origin = (seg: Segment.t): option(Point.t) =>
+let segment_origin = (~folded=[], seg: Segment.t): option(Point.t) =>
   Option.map(
-    first => find_p(first, of_segment(seg)).origin,
+    first => find_p(first, of_segment(seg, ~folded)).origin,
     ListUtil.hd_opt(seg),
   );
 
-let segment_last = (seg: Segment.t): option(Point.t) =>
+let segment_last = (~folded=[], seg: Segment.t): option(Point.t) =>
   Option.map(
-    last => find_p(last, of_segment(seg)).last,
+    last => find_p(last, of_segment(seg, ~folded)).last,
     ListUtil.last_opt(seg),
   );
 
-let segment_height = (seg: Segment.t) =>
-  switch (segment_last(seg), segment_origin(seg)) {
+let segment_height = (~folded=[], seg: Segment.t) =>
+  switch (segment_last(seg, ~folded), segment_origin(seg, ~folded)) {
   | (Some(last), Some(first)) => 1 + last.row - first.row
   | _ => 0
   };
 
-let segment_width = (seg: Segment.t): int =>
+let segment_width = (~folded=[], seg: Segment.t): int =>
   IntMap.fold(
     (_, {max_col, _}: Rows.shape, acc) => max(max_col, acc),
-    of_segment(seg).rows,
+    of_segment(seg, ~folded).rows,
     0,
   );

src/haz3lcore/statics/Module.re

@@ -50,3 +50,13 @@ let rec get_module =
   | _ => None
   };
 };
+
+let foldable = (tile: Tile.t) =>
+  tile.label == ["module", "=", "in"]
+  && List.length(tile.shards) == List.length(tile.label);
+let foldable_anc = (tile: Ancestor.t) => {
+  let (s1, s2) = tile.shards;
+  let shard_length = List.length(s1) + List.length(s2);
+  tile.label == ["module", "=", "in"]
+  && shard_length == List.length(tile.label);
+};

src/haz3lcore/zipper/Editor.re

@@ -7,6 +7,7 @@ module Meta = {
     measured: Measured.t,
     term_ranges: TermRanges.t,
     col_target: int,
+    folded: list(Id.t),
   };
 
   let init = (z: Zipper.t) => {
@@ -16,6 +17,7 @@ module Meta = {
       measured: Measured.of_segment(unselected),
       term_ranges: TermRanges.mk(unselected),
       col_target: 0,
+      folded: [],
     };
   };
 
@@ -42,18 +44,25 @@ module Meta = {
 
   let next =
       (~effects: list(Effect.t)=[], a: Action.t, z: Zipper.t, meta: t): t => {
-    let {touched, measured, col_target, _} = meta;
+    let {touched, measured, col_target, folded, _} = meta;
     let touched = Touched.update(Time.tick(), effects, touched);
     let unselected = Zipper.unselect_and_zip(z);
-    let measured = Measured.of_segment(~touched, ~old=measured, unselected);
+    let folded =
+      switch (a) {
+      | Fold(id) => [id, ...folded]
+      | Unfold(id) => List.filter(x => x !== id, folded)
+      | _ => folded
+      };
+    let measured =
+      Measured.of_segment(~touched, ~old=measured, unselected, ~folded);
     let term_ranges = TermRanges.mk(unselected);
     let col_target =
       switch (a) {
       | Move(Local(Up | Down))
       | Select(Resize(Local(Up | Down))) => col_target
       | _ => Zipper.caret_point(measured, z).col
       };
-    {touched, measured, term_ranges, col_target};
+    {touched, measured, term_ranges, col_target, folded};
   };
 };
 

src/haz3lcore/zipper/action/Action.re

@@ -40,6 +40,8 @@ type t =
   | Insert(string)
   | RotateBackpack
   | MoveToBackpackTarget(planar)
+  | Fold(Id.t)
+  | Unfold(Id.t)
   | Pick_up
   | Put_down;
 

src/haz3lcore/zipper/action/Move.re

@@ -73,23 +73,58 @@ module Make = (M: Editor.Meta.S) => {
   let inner_end = (d, d_init, c_max, z) =>
     z |> Zipper.set_caret(Inner(d_init, c_max)) |> Zipper.move(d);
 
-  let primary = (chunkiness: chunkiness, d: Direction.t, z: t): option(t) => {
-    switch (d, z.caret, neighbor_movability(chunkiness, z)) {
+  let can_pass_fold =
+      (
+        folded,
+        d: Direction.t,
+        {relatives: {ancestors, siblings: (l_sib, r_sib)}, _}: t,
+      ) => {
+    switch (d, ancestors) {
+    | (Left, [({id, children: (l_kids, _), _}, _), ..._])
+        when List.mem(id, folded) && List.length(l_kids) == 1 && l_sib != [] =>
+      Some(id)
+    | (Right, [({id, children: (l_kids, _), _}, _), ..._])
+        when List.mem(id, folded) && List.length(l_kids) == 1 && r_sib != [] =>
+      Some(id)
+    | _ => None
+    };
+  };
+  let rec pass_fold = (d: Direction.t, z: t, target_id) => {
+    switch (d, z.relatives.siblings, z.relatives.ancestors) {
+    | (Left, ([], _), [({id, _}, _), ..._])
+    | (Right, (_, []), [({id, _}, _), ..._]) when id == target_id =>
+      Some(z)
+    | _ =>
+      let* z = Zipper.move(d, z);
+      pass_fold(d, z, target_id);
+    };
+  };
+
+  let primary =
+      (~folded=[], chunkiness: chunkiness, d: Direction.t, z: t): option(t) => {
+    switch (
+      d,
+      z.caret,
+      neighbor_movability(chunkiness, z),
+      can_pass_fold(folded, d, z),
+    ) {
     /* this case maybe shouldn't be necessary but currently covers an edge
        (select an open parens to left of a multichar token and press left) */
     | _ when z.selection.content != [] => pop_move(d, z)
-    | (Left, Outer, (CanEnter(dlm, c_max), _)) =>
+    | (Left, Outer, _, Some(target_id)) => pass_fold(d, z, target_id)
+    | (Left, Outer, (CanEnter(dlm, c_max), _), _) =>
       inner_end(d, dlm, c_max, z)
-    | (Left, Outer, _) => Zipper.move(d, z)
-    | (Left, Inner(_), _) when chunkiness == ByToken => pop_out(z)
-    | (Left, Inner(_), _) =>
+    | (Left, Outer, _, _) => Zipper.move(d, z)
+    | (Left, Inner(_), _, _) when chunkiness == ByToken => pop_out(z)
+    | (Left, Inner(_), _, _) =>
       Some(Zipper.update_caret(Zipper.Caret.decrement, z))
-    | (Right, Outer, (_, CanEnter(d_init, _))) => inner_start(d_init, z)
-    | (Right, Outer, _) => Zipper.move(d, z)
-    | (Right, Inner(_, c), (_, CanEnter(_, c_max))) when c == c_max =>
+    | (Right, Outer, _, Some(target_id)) => pass_fold(d, z, target_id)
+    | (Right, Outer, (_, CanEnter(d_init, _)), _) => inner_start(d_init, z)
+    | (Right, Outer, _, _) => Zipper.move(d, z)
+    | (Right, Inner(_, c), (_, CanEnter(_, c_max)), _) when c == c_max =>
       pop_move(d, z)
-    | (Right, Inner(_), _) when chunkiness == ByToken => pop_move(d, z)
-    | (Right, Inner(delim, c), _) => inner_incr(delim, c, z)
+    | (Right, Inner(_), _, _) when chunkiness == ByToken => pop_move(d, z)
+    | (Right, Inner(delim, c), _, _) => inner_incr(delim, c, z)
     };
   };
 
@@ -219,11 +254,11 @@ module Make = (M: Editor.Meta.S) => {
   /* Do move_action until the indicated piece is such that piece_p is true,
      restarting from the beginning/end if not found in forward direction.
      If no such piece is found, don't move. */
-  let do_until_wrap = (p, d, z) =>
-    switch (do_until(primary(ByToken, d), p, z)) {
+  let do_until_wrap = (p, d, z, ~folded) =>
+    switch (do_until(primary(ByToken, d, ~folded), p, z)) {
     | None =>
       let* z = to_edge(Direction.toggle(d), z);
-      do_until(primary(ByToken, d), p, z);
+      do_until(primary(ByToken, d, ~folded), p, z);
     | Some(z) => Some(z)
     };
 
@@ -316,19 +351,19 @@ module Make = (M: Editor.Meta.S) => {
     };
   };
 
-  let go = (d: Action.move, z: Zipper.t): option(Zipper.t) =>
+  let go = (d: Action.move, z: Zipper.t, ~folded): option(Zipper.t) =>
     switch (d) {
-    | Goal(Piece(p, d)) => do_until_wrap(p, d, z)
+    | Goal(Piece(p, d)) => do_until_wrap(p, d, z, ~folded)
     | Goal(Point(goal)) =>
       let z = Zipper.unselect(z);
-      do_towards(primary(ByChar), goal, z);
+      do_towards(primary(ByChar, ~folded), goal, z);
     | Extreme(d) => do_extreme(primary(ByToken), d, z)
     | Local(d) =>
       z
       |> (
         switch (d) {
-        | Left(chunk) => primary(chunk, Left)
-        | Right(chunk) => primary(chunk, Right)
+        | Left(chunk) => primary(chunk, Left, ~folded)
+        | Right(chunk) => primary(chunk, Right, ~folded)
         | Up => vertical(Left)
         | Down => vertical(Right)
         }

src/haz3lcore/zipper/action/Perform.re

@@ -5,6 +5,8 @@ let is_write_action = (a: Action.t) => {
   switch (a) {
   | Move(_)
   | MoveToNextHole(_)
+  | Fold(_)
+  | Unfold(_)
   | Unselect
   | Jump(_)
   | Select(_) => false
@@ -29,15 +31,26 @@ let go_z =
   module Move = Move.Make(M);
   module Select = Select.Make(M);
   switch (a) {
+  | Fold(tid)
+  | Unfold(tid) =>
+    switch (Measured.find_by_id(tid, meta.measured)) {
+    | Some({origin, _}) =>
+      switch (Move.go(Goal(Point(origin)), z, ~folded=meta.folded)) {
+      | Some(z) => Ok(z)
+      | None => Ok(z)
+      }
+    | None => Error(Action.Failure.Cant_move)
+    }
   | Move(d) =>
-    Move.go(d, z) |> Result.of_option(~error=Action.Failure.Cant_move)
+    Move.go(d, z, ~folded=meta.folded)
+    |> Result.of_option(~error=Action.Failure.Cant_move)
   | MoveToNextHole(d) =>
     let p: Piece.t => bool = (
       fun
       | Grout(_) => true
       | _ => false
     );
-    Move.go(Goal(Piece(p, d)), z)
+    Move.go(Goal(Piece(p, d)), z, ~folded=meta.folded)
     |> Result.of_option(~error=Action.Failure.Cant_move);
   | Jump(jump_target) =>
     open OptUtil.Syntax;

src/haz3lweb/Editors.re

@@ -46,6 +46,8 @@ let put_editor = (ed: Editor.t, eds: t): t =>
   };
 
 let get_zipper = (editors: t): Zipper.t => get_editor(editors).state.zipper;
+let get_folded = (editors: t): list(Id.t) =>
+  get_editor(editors).state.meta.folded;
 
 /* Each mode (e.g. Scratch, School) requires
    elaborating on some number of expressions