zipper -package:traverse-with-class

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:

• Top :>> a represents a trivial Zipper with its focus at the root.
• Top :>> Tree a :>> a represents a Zipper that starts with a Tree and descends in a single step to values of type a.
• Top :>> Tree a :>> Tree a :>> Tree a represents a Zipper into a Tree with an intermediate bookmarked Tree, focusing in yet another Tree.

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.

This is an infinite bidirectional zipper

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.