zipper -package:streams -package:traverse-with-class -package:rosezipper -package:Agda
Create a zipper, focused on the top-left value.
Construct a
Zipper that can explore anything, and start it at
the
Top.
Not on Stackage, so not searched.
Generic zipper for families of recursive datatypes
A zipper is a structure for walking a value and manipulating it in
constant time.
This module was inspired by the paper: Michael D. Adams. Scrap Your
Zippers: A Generic Zipper for Heterogeneous Types, Workshop on Generic
Programming 2010.
Zipper structure, whose root type is the first type argument, and
whose focus type is the second type argument.
This module provides a two-dimensional text zipper data structure.
This structure represents a body of text and an editing cursor which
can be moved throughout the text, along with a set of editing
transformations.
Text zippers are generalized over the set of data types that might be
used to store lists of characters (e.g.,
String,
Text,
etc.). As a result, the most general way to create a text zipper is to
use
mkZipper and provide all of the functions required to
manipulate the underlying text data.
Implementations using
Text and
String are provided.
This module provides a
Zipper with fairly strong type checking
guarantees.
The code here is inspired by Brandon Simmons'
zippo package,
but uses a different approach to represent the
Zipper that
makes the whole thing look like his breadcrumb trail, and can move
side-to-side through traversals.
Some examples types:
Since individual levels of a
Zipper are managed by an arbitrary
IndexedTraversal, you can move left and right through the
IndexedTraversal selecting neighboring elements.
>>> zipper ("hello","world") & downward _1 & fromWithin traverse & focus .~ 'J' & rightmost & focus .~ 'y' & rezip
("Jelly","world")
This is particularly powerful when compiled with
plate,
uniplate or
biplate for walking down into self-similar
children in syntax trees and other structures.
Given keys in ascending order you can jump directly to a given key
with
moveTo. When used with traversals for balanced tree-like
structures such as an
IntMap or
Map, searching for a key
with
moveTo can be done in logarithmic time.
This is the type of a
Zipper. It visually resembles a
"breadcrumb trail" as used in website navigation. Each breadcrumb in
the trail represents a level you can move up to.
This type operator associates to the left, so you can use a type like
Top :>> (String,Double) :>> String :>> Char
to represent a
Zipper from
(String,Double) down to
Char that has an
intermediate crumb for the
String containing the
Char.
You can construct a
Zipper into *any* data structure with
zipper.
You can repackage up the contents of a
Zipper with
rezip.
>>> rezip $ zipper 42
42
The combinators in this module provide lot of things you can do to the
Zipper while you have it open.
Note that a value of type
h :> s :> a
doesn't actually contain a value of type
h :> s --
as we descend into a level, the previous level is unpacked and stored
in
Coil form. Only one value of type
_ :> _
exists at any particular time for any particular
Zipper.
Creation date: Thu Jul 23 08:42:37 2020.
Spine-lazy radix tree location manipulation.
Allows lookup and successive insertion without retaining the entirety
of the key in memory.
Spine-strict radix tree location manipulation.
Allows lookup and successive insertion without retaining the entirety
of the key in memory.
Create a zipper with a different focus type from the outer type. Will
return Nothing if there are no instances of the focus type
within the original value.
differentiate zs xs takes the first
z from
z2
that also belongs to xs
and turns xs
into a stack
with z
being the current element. Acts as
differentiate if zs
and xs@ don't intersect.
Traversal based zippers
Traversal based zippers.
Not on Stackage, so not searched.
Zipper utils that weren't in Control.Comonad.Store.Zipper
Not on Stackage, so not searched.
An implementationg of Attribute Grammars using Functional Zippers
Zipper for rose trees
A zipper consist of the current tree and the branches on the way back
to the root
Conversion of a navigatable rose tree into an ordinary rose tree.
The context, the parts for moving up to the root are just removed from
the tree. So when transforming a navigatable tree by moving around and
by changing some nodes, one has to navigate back to the root, else
that parts are removed from the result