refactor: naming convention in zipper

Unless specified otherwise:
- "before" and "left" mean "before the cursor";
- "right" mean "after (and including) the cursor";
- "after" mean "after (i.e., excluding) the cursor".

1 files changed, 42 insertions, 54 deletions

diff --git a/lib/zipper.ml b/lib/zipper.ml
index 9313518..202f6d4 100644
--- a/lib/zipper.ml
+++ b/lib/zipper.ml
@@ -2,28 +2,14 @@
 
 open Base
 
-type !+'a zipper = {
-  pos : int;
-  popped : 'a Sequence.t;
-  before : 'a Sequence.t;
-  after : 'a Sequence.t;
-}
-
+type !+'a zipper = { pos : int; before : 'a Sequence.t; after : 'a Sequence.t }
 type !+'a t = 'a zipper
 
-let empty =
-  {
-    pos = 0;
-    popped = Sequence.empty;
-    before = Sequence.empty;
-    after = Sequence.empty;
-  }
-
+let empty = { pos = 0; before = Sequence.empty; after = Sequence.empty }
 let before z = z.before
 let after z = z.after
 let focus z = after z |> Sequence.next |> Option.map ~f:fst
-let focus_or z ~default = Option.value ~default (focus z)
-let history z = z.popped
+let focus_or ~default z = Option.value ~default (focus z)
 let is_far_left z = before z |> Sequence.is_empty
 let is_far_right z = after z |> Sequence.is_empty
 let is_empty z = is_far_left z && is_far_right z
@@ -35,12 +21,7 @@ let left z =
   match Sequence.next z.before with
   | None -> z
   | Some (h, t) ->
-      {
-        z with
-        pos = z.pos - 1;
-        before = t;
-        after = Sequence.shift_right z.after h;
-      }
+      { pos = z.pos - 1; before = t; after = Sequence.shift_right z.after h }
 
 let rec left_while f z =
   if (not (is_far_left z)) && Option.(focus z |> map ~f |> value ~default:false)
@@ -53,12 +34,7 @@ let right z =
   match Sequence.next z.after with
   | None -> z
   | Some (h, t) ->
-      {
-        z with
-        pos = z.pos + 1;
-        before = Sequence.shift_right z.before h;
-        after = t;
-      }
+      { pos = z.pos + 1; before = Sequence.shift_right z.before h; after = t }
 
 let rec right_while f z =
   if
@@ -73,34 +49,46 @@ let goto n z =
   let step = if n < 0 then left else right in
   Fn.apply_n_times ~n:(abs n) step z
 
-let pop_after z = { z with after = Sequence.drop_eagerly z.after 1 }
-let pop_before z = if is_far_left z then z else z |> left |> pop_after
-let pop = pop_before
-let push_after x z = { z with after = Sequence.shift_right z.after x }
+let pop ?(n = 1) z = { z with after = Sequence.drop_eagerly z.after n }
+
+let pop_before ?(n = 1) =
+  let rec aux m z =
+    if m < n && not (is_far_left z) then aux (m + 1) (left z) else pop ~n:m z
+  in
+  aux 0
+
+let pop_after ?(n = 1) z =
+  if right_length z < 2 then z else right z |> pop ~n |> left
+
+let push x z = { z with after = Sequence.shift_right z.after x }
+let push_after x z = right z |> push x |> left
 
 let push_before x z =
   { z with pos = z.pos + 1; before = Sequence.shift_right z.before x }
 
-let push = push_before
-
 let split z =
   ( { z with after = Sequence.empty },
     { z with pos = 0; before = Sequence.empty } )
 
-let join z1 z2 = { z1 with after = z2.after }
-let iter_before f z = Sequence.iter ~f z.before
-let iter_after f z = Sequence.iter ~f z.after
+let join z1 ~z2 =
+  let z1 = far_right z1 and z2 = far_left z2 in
+  { z1 with after = z2.after }
+
+let iter_left f z = Sequence.iter ~f z.before
+let iter_right f z = Sequence.iter ~f z.after
 
 let iter f z =
-  iter_before f z;
-  iter_after f z
+  iter_left f z;
+  iter_right f z
 
 let for_all f z = Sequence.(for_all ~f z.before && for_all ~f z.after)
 let exists f z = Sequence.(exists ~f z.before || exists ~f z.after)
-let find_before f z = Sequence.find ~f z.before
-let find_after f z = Sequence.find ~f z.after
-let map_before f z = { z with before = Sequence.map ~f z.before }
-let map_after f z = { z with after = Sequence.map ~f z.after }
+let find_left f z = Sequence.find ~f z.before
+let find_right f z = Sequence.find ~f z.after
+let apply_focus f z = Option.map ~f (focus z)
+let apply_focus_or ~default f z = Option.value ~default (apply_focus f z)
+let map_left f z = { z with before = Sequence.map ~f z.before }
+let map_right f z = { z with after = Sequence.map ~f z.after }
 
 let map_focus f z =
   match Sequence.next z.after with
@@ -115,8 +103,8 @@ let map_focus_or ~default f z =
 let map f z =
   { z with before = Sequence.map ~f z.before; after = Sequence.map ~f z.after }
 
-let mapi_before f z = { z with before = Sequence.mapi ~f z.before }
-let mapi_after f z = { z with after = Sequence.mapi ~f z.after }
+let mapi_left f z = { z with before = Sequence.mapi ~f z.before }
+let mapi_right f z = { z with after = Sequence.mapi ~f z.after }
 
 let mapi f z =
   {
@@ -125,13 +113,13 @@ let mapi f z =
     after = Sequence.mapi ~f z.after;
   }
 
-let filter_before f z = { z with before = Sequence.filter ~f z.before }
-let filter_after f z = { z with after = Sequence.filter ~f z.after }
-let filter p z = z |> filter_before p |> filter_after p
-let context_before n z = { z with before = Sequence.take z.before n }
-let context_after n z = { z with after = Sequence.take z.after n }
-let context ~b ?(a = b) z = z |> context_before b |> context_after a
-let clear_history z = { z with popped = Sequence.empty }
+let filter_left f z = { z with before = Sequence.filter ~f z.before }
+let filter_right f z = { z with after = Sequence.filter ~f z.after }
+let filter p z = z |> filter_left p |> filter_right p
+let context_left n z = { z with before = Sequence.take z.before n }
+let context_right n z = { z with after = Sequence.take z.after n }
+let context ~l ?(r = l) z = z |> context_left l |> context_right r
+let swap_focus a = map_focus (Fn.const a)
 let of_seq s = { empty with after = s }
 let to_seq z = z |> far_left |> after
-let window ~from ~len z = goto from z |> context_after len |> after
+let window ~from ~len z = goto from z |> context_right len |> after