S_non_monadic contains the core operations of a zipper, without any parametrisation over a particular failure monad.
include Sexplib0.Sexpable.S1 with type 'a t := 'a t
val t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a t
val sexp_of_t : ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.t
Construction and destruction
make ~left ~right constructs a zipper with left list
left and right list
These lists go directly into the zipper itself, so
left, if non-empty, should be in the reverse order to how it should appear when fully rewound.
of_list xs converts a list
xs to a fully-rewound zipper.
It is equivalent to
make with an empty
to_list zipper returns the list of _all_ items in the zipper, including those in the left list.
All items appear in the same order that they would take in the right list if the zipper was fully rewound. In other words, the left list appears first (in reverse order), followed by the right list (in forwards order).
To get only the items in the right list, use
right_list; to get only the items in the left list (reversed), use
Querying the left and right lists
left_list zipper gets the raw left list of the zipper: all of the already-processed items in reverse order.
right_list zipper gets the right list of the zipper: all of the not-yet-processed items in forwards order.
to_two_lists zipper is
(left_list zipper, right_list zipper).
push zipper ~value pushes
zipper at the cursor. The current cursor becomes the second item in the right list, and so on.
push_left zipper ~value pushes
zipper just to the left of the cursor.
Peeking and popping
val peek_opt : ?steps:Base.int -> 'a t -> 'a Base.option
peek_opt ?steps zipper retrieves the cursor value without popping it from the zipper. If the cursor is empty,
None is returned.
steps is given, it shifts the effective cursor
steps places forwards.
val pop : 'a t -> ('a * 'a t) Base.Or_error.t
pop zipper returns an error if
zipper has no cursor, or
Ok (a, zipper') where
zipper's cursor and
zipper' is the new zipper formed by removing
val pop_opt : 'a t -> ('a * 'a t) Base.option
pop_opt zipper behaves as pop, but returns
zipper has no cursor and
Some (a, zipper') otherwise.
val map_head : 'a t -> f:('a -> 'a Base.option) -> 'a t
map_head zipper ~f maps
f across the cursor of
zipper, if it exists, and replaces the cursor with the result (or drops it if
val step : ?steps:Base.int -> 'a t -> 'a t Base.Or_error.t
step ?steps zipper ~on_empty takes one or more steps across
zipper. The number of steps defaults to 1 (forwards), but can be given by
steps; negative numbers step backwards through the zipper. If the number of steps exceeds the bounds of the zipper, an error is returned.