Control.Lens.Zipper

This module provides a Zipper with fairly strong type checking guarantees.

The code here is inspired by Brandon Simmons' zippo package, but uses a slightly 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 Traversal, you can move left and right through the Traversal selecting neighboring elements.

>>> zipper ("hello","world") & down _1 & fromWithin traverse & focus .~ 'J' & farthest right & 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.

Zippers

data Top

This is used to represent the Top of the Zipper.

Every Zipper starts with Top.

e.g. Top :> a is the trivial zipper.

Instances

Zipper Top a

data p :> a

This is the type of a Zipper. It visually resembes 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.

Instances

Zipper h b => Zipper (:> h b) c

zipper :: a -> Top :> a

Construct a zipper that can explore anything.

Focusing

focus :: SimpleIndexedLens (Tape (h :> a)) (h :> a) a

This Lens views the current target of the zipper.

Horizontal Movement

up :: ((a :> b) :> c) -> a :> b

Move the zipper up, closing the current level and focusing on the parent element.

down :: SimpleLensLike (Context c c) b c -> (a :> b) -> (a :> b) :> c

Step down into a Lens. This is a constrained form of fromWithin for when you know there is precisely one target.

 down :: Simple Lens b c -> (a :> b) -> a :> b :> c
 down :: Simple Iso b c  -> (a :> b) -> a :> b :> c

within :: SimpleLensLike (Bazaar c c) b c -> (a :> b) -> Maybe ((a :> b) :> c)

Step down into the leftmost entry of a Traversal.

 within :: Simple Traversal b c -> (a :> b) -> Maybe (a :> b :> c)
 within :: Simple Lens b c      -> (a :> b) -> Maybe (a :> b :> c)
 within :: Simple Iso b c       -> (a :> b) -> Maybe (a :> b :> c)

Lateral Movement

left :: (a :> b) -> Maybe (a :> b)

Pull the zipper left within the current Traversal.

right :: (a :> b) -> Maybe (a :> b)

Pull the entry one entry to the right

Movement Combinators

tug :: (a -> Maybe a) -> a -> a

This allows you to safely 'tug left' or 'tug right' on a zipper.

The more general signature allows its use in other circumstances, however.

tugs :: (a -> Maybe a) -> Int -> a -> a

This allows you to safely 'tug left' or 'tug right' on a zipper, moving multiple steps in a given direction, stopping at the last place you couldn't move from.

jerks :: (a -> Maybe a) -> Int -> a -> Maybe a

This allows for you to repeatedly pull a zipper in a given direction, failing if it falls of the end.

farthest :: (a -> Maybe a) -> a -> a

Move in a direction as far as you can go, then stop.

Absolute Positioning

tooth :: (a :> b) -> Int

Return the index into the current Traversal within the current level of the zipper.

jerkTo (tooth l) l = Just'

teeth :: (a :> b) -> Int

Returns the number of siblings at the current level in the zipper.

teeth z >= 1

NB: If the current Traversal targets an infinite number of elements then this may not terminate.

jerkTo :: Int -> (a :> b) -> Maybe (a :> b)

Move the zipper horizontally to the element in the nth position in the current level, absolutely indexed, starting with the farthest left as 0.

This returns Nothing if the target element doesn't exist.

jerkTo n ≡ jerks right n . farthest left

tugTo :: Int -> (a :> b) -> a :> b

Move the zipper horizontally to the element in the nth position of the current level, absolutely indexed, starting with the farthest left as 0.

If the element at that position doesn't exist, then this will clamp to the range 0 <= n < teeth.

tugTo n ≡ tugs right n . farthest left

Closing the zipper

rezip :: Zipper h a => (h :> a) -> Zipped h a

Close something back up that you opened as a zipper.

type family Zipped h a

This represents the type a zipper will have when it is fully Zipped back up.

class Zipper h a

This enables us to pull the zipper back up to the Top.

Instances

Zipper Top a

Zipper h b => Zipper (:> h b) c

Recording

data Tape k

A Tape is a recorded path through the Traversal chain of a Zipper.

saveTape :: (a :> b) -> Tape (a :> b)

Save the current path as as a Tape we can play back later.

restoreTape :: Tape (h :> a) -> Zipped h a -> Maybe (h :> a)

Restore ourselves to a previously recorded position precisely.

If the position does not exist, then fail.

restoreNearTape :: Tape (h :> a) -> Zipped h a -> Maybe (h :> a)

Restore ourselves to a location near our previously recorded position.

When moving left to right through a Traversal, if this will clamp at each level to the range 0 <= k < teeth, so the only failures will occur when one of the sequence of downward traversals find no targets.

Unsafe Movement

fromWithin :: SimpleLensLike (Bazaar c c) b c -> (a :> b) -> (a :> b) :> c

Unsafely step down into a Traversal that is assumed to be non-empty.

If this invariant is not met then this will usually result in an error!

 fromWithin :: Simple Traversal b c -> (a :> b) -> a :> b :> c
 fromWithin :: Simple Lens b c      -> (a :> b) -> a :> b :> c
 fromWithin :: Simple Iso b c       -> (a :> b) -> a :> b :> c

You can reason about this function as if the definition was:

fromWithin l ≡ fromJust . within l

but it is lazier in such a way that if this invariant is violated, some code can still succeed if it is lazy enough in the use of the focused value.

unsafelyRestoreTape :: Tape (h :> a) -> Zipped h a -> h :> a

Restore ourselves to a previously recorded position.

This *assumes* that nothing has been done in the meantime to affect the existence of anything on the entire path.

Motions left or right are clamped, but all traversals included on the Tape are assumed to be non-empty.

Violate these assumptions at your own risk!