Data.Zipper.ArrayZipper

newtype ArrayZipper a

An immutable Zipper for an Array.

This Zipper works well in read-heavy code but might not work well in write-heavy code

Modifications to the focused element are O(n) due to creating a new immutable array with the change rather than mutating the underlying array.

Navigating to a new focus element is O(1) regardless of how far away from the current focus that element is. This is in contrast to a List-based zipper where modifications are O(1) and navigation is O(n).

[0, 1, 2, 3, 4, 5] <-- underlying array
         ^      ^
         |      -- maxIndex
         -- focusIndex

Instances

• (Eq a) => Eq (ArrayZipper a)
• (Ord a) => Ord (ArrayZipper a)
• Functor ArrayZipper
• (Show a) => Show (ArrayZipper a)
• FunctorWithIndex Int ArrayZipper
• Foldable ArrayZipper
• FoldableWithIndex Int ArrayZipper
• Traversable ArrayZipper
• TraversableWithIndex Int ArrayZipper
• Extend ArrayZipper

  Given a function, f, passes in n-many versions of this zipper to that function where n corresponds to the number of elements within the array and each version of the zipper will focus the element at the nth index.

• Comonad ArrayZipper

  Gets the focused element (i.e. same as getFocus).

• (Arbitrary a) => Arbitrary (ArrayZipper a)
• (Coarbitrary a) => Coarbitrary (ArrayZipper a)

asArrayZipper :: forall a. a -> ArrayZipper a

Creates an Array Zipper from a single element. This will be stored internally as a 1-element array. To further build upon this array, see push* functions.

toArrayZipperFirst :: forall a. Array a -> Maybe (ArrayZipper a)

Returns Nothing if the array is empty. Otherwise, returns an ArrayZipper with the first element as the focus.

toArrayZipperLast :: forall a. Array a -> Maybe (ArrayZipper a)

Returns Nothing if the array is empty. Otherwise, returns an ArrayZipper with the last element as the focus.

toArrayZipperAt :: forall a. Int -> Array a -> Maybe (ArrayZipper a)

Returns Nothing if the array is empty. Otherwise, returns an ArrayZipper with the element at the given index as the focus. The given index will be clamped within the array's bounds to ensure it always refers to a valid element in the array. To return Nothing on an invalid index, see toArrayZipperAt'.

toArrayZipperAt' :: forall a. Int -> Array a -> Maybe (ArrayZipper a)

Returns Nothing if the array is empty or if the given index is outside the bounds of the array. Otherwise, returns an ArrayZipper with the element at the given index as the focus. To return Just zipper by clamping an invalid index, so that it is within the array, see toArrayZipperAt.

exposeArray :: forall a. ArrayZipper a -> Array a

Exposes the underlying array. Note: any mutations to this array via unsafeThaw will invalidate the constraints guaranteed by ArrayZipper.

exposeMaxIndex :: forall a. ArrayZipper a -> Int

Exposes the index of the last element

exposeFocusIndex :: forall a. ArrayZipper a -> Int

Exposes the index of the focused element

hasPrev :: forall a. ArrayZipper a -> Boolean

Returns true if prev will return a Just

hasNext :: forall a. ArrayZipper a -> Boolean

Returns true if prev will return a Just

prev :: forall a. ArrayZipper a -> Maybe (ArrayZipper a)

Returns Nothing if the focus element is the first element in the array. Otherwise, returns Just where the new focus element is the previous element.

next :: forall a. ArrayZipper a -> Maybe (ArrayZipper a)

Returns Nothing if the focus element is the last element in the array. Otherwise, returns Just where the new focus element is the next element.

shiftFocusBy :: forall a. (Int -> Int) -> ArrayZipper a -> ArrayZipper a

Use a function to focus a different element in the array by using the zipper's current focus index. If the resulting index is outside the bounds of the array, the index will refer to the first or last element, whichever is closer to the output of the function. To prevent clamping and return Nothing if the output of the function is an invalid index, see shiftFocusBy'.

shiftFocusBy' :: forall a. (Int -> Int) -> ArrayZipper a -> Maybe (ArrayZipper a)

Use a function to focus a different element in the array by using the zipper's current focus index. If the resulting index is outside the bounds of the array, Nothing is returned. If it's a valid index, Just zipper is returned.

shiftFocusByFind :: forall a. (a -> Boolean) -> ArrayZipper a -> ArrayZipper a

Use a function to find and focus the first matching element in the array. If no element matches, the zipper is returned unchanged.

shiftFocusByFind' :: forall a. (a -> Boolean) -> ArrayZipper a -> Maybe (ArrayZipper a)

Use a function to find and the first matching element in the array. If no element matches, Nothing is returned. If an element matches, Just zipper is returned.

shiftFocusTo :: forall a. Eq a => a -> ArrayZipper a -> ArrayZipper a

Find and focus the first equal element in the array. If no element is equal, the zipper is returned unchanged.

shiftFocusTo' :: forall a. Eq a => a -> ArrayZipper a -> Maybe (ArrayZipper a)

Find and focus the first equal element in the array. If no element is equal, Nothing is returned. If an element is equal, Just zipper is returned.

shiftFocusFirst :: forall a. ArrayZipper a -> ArrayZipper a

Changes the focus element to the first element in the array.

shiftFocusLast :: forall a. ArrayZipper a -> ArrayZipper a

Changes the focus element to the last element in the array.

getFocus :: forall a. ArrayZipper a -> a

Returns the focus element. O(1)

setFocus :: forall a. a -> ArrayZipper a -> ArrayZipper a

Sets the focus element. O(n)

modifyFocus :: forall a. (a -> a) -> ArrayZipper a -> ArrayZipper a

Uses a function to update the focus element. O(n)

pushPrev :: forall a. a -> ArrayZipper a -> ArrayZipper a

Inserts an element in front of / to the left of the focus element. O(n)

pushNext :: forall a. a -> ArrayZipper a -> ArrayZipper a

Inserts an element behind / to the right of the focus element. O(n)

pushPrevRefocus :: forall a. a -> ArrayZipper a -> ArrayZipper a

Inserts an element in front of / to the left of the focus element and sets this new element as the focus element. O(n)

pushNextRefocus :: forall a. a -> ArrayZipper a -> ArrayZipper a

Inserts an element behind / to the right of the focus element and sets this new element as the focus element. O(n)