Zipper.Make_marked
Make_marked
makes a marked zipper from a Basic_mark
.
module Mark : Zipper_types.Basic_mark
include Zipper_types.S_marked_non_monadic with type mark := Mark.t
include Zipper_types.S_non_monadic
val make : left:'a Base.list -> right:'a Base.list -> 'a t
make ~left ~right
constructs a zipper with left list left
and right list right
.
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.
val of_list : 'a Base.list -> 'a t
of_list xs
converts a list xs
to a fully-rewound zipper.
It is equivalent to make
with an empty left
.
val to_list : 'a t -> 'a Base.list
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 left_list
.
val left_list : 'a t -> 'a Base.list
left_list zipper
gets the raw left list of the zipper: all of the already-processed items in reverse order.
val right_list : 'a t -> 'a Base.list
right_list zipper
gets the right list of the zipper: all of the not-yet-processed items in forwards order.
val to_two_lists : 'a t -> 'a Base.list * 'a Base.list
to_two_lists zipper
is (left_list zipper, right_list zipper)
.
val left_length : 'a t -> Base.int
left_length zipper
gets the length of zipper
's left list.
val right_length : 'a t -> Base.int
right_length zipper
gets the length of zipper
's right list.
val is_at_start : 'a t -> Base.bool
is_at_start zipper
tests whether zipper
's left list is empty.
val is_at_end : 'a t -> Base.bool
is_at_end zipper
tests whether zipper
's right list is empty.
push zipper ~value
pushes value
into zipper
at the cursor. The current cursor becomes the second item in the right list, and so on.
push_left zipper ~value
pushes value
into zipper
just to the left of the cursor.
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.
If steps
is given, it shifts the effective cursor steps
places forwards.
pop zipper
returns an error if zipper
has no cursor, or Ok (a, zipper')
where a
is zipper
's cursor and zipper'
is the new zipper formed by removing a
.
pop_opt zipper
behaves as pop
, but returns None
if zipper
has no cursor and Some (a, zipper')
otherwise.
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 f
returns None
).
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.
mark zipper ~mark
marks the cursor with mark
, and returns the marked-up zipper.
If the cursor is empty, an error is returned.
recall zipper ~mark
rewinds zipper
until the cursor is on an element previously marked with mark
.
If recall
runs out of left-list to rewind before finding mark
, an error is returned.
val fold_until :
'a t ->
f:
('acc ->
'a ->
'a t ->
(Mark.t, 'a, 'acc, 'final) Zipper_types.fold_outcome) ->
init:'acc ->
finish:('acc -> 'a t -> 'final) ->
'final
fold_until zipper ~f ~init ~finish
behaves conceptually like List.fold_until
, but folds f
through the remaining elements of a zipper.
f
receives the current accumulator, current cursor, and zipper with cursor popped at each stage. It can't directly modify the zipper mid-fold, but can influence the value of the final zipper provided to the finish
continuation by using the various legs of fold_outcome
.
module On_monad
(M : Base.Monad.S) :
Zipper_types.S_marked_monadic
with type 'a t := 'a t
and type mark := Mark.t
and module M := M
On_monad
provides various marked zipper operations parametrised by a monad.
module On_ident : sig ... end
On_ident
is On_monad
specialised to the identity monad.
module On_error : sig ... end
On_error
is On_monad
specialised to the error monad.
module On_option : sig ... end
On_option
is On_monad
specialised to the option monad.