Data.List.NonEmptyZipper

Its the Zipper for NonEmpty lists.

Documentation

data NonEmptyZipper a

A Zipper with a "current element". The current element represent a singular, focus on a single element in a list. So NonEmptyZipper [1,2] 3 [4] is roughly eqivelant to [1,2,3,4], where 3 is the current element. This is useful, since we are now guarenteed that the current element is an element in the list.

Constructors

NonEmptyZipper

A list of element succeeding the current element.

Fields

• _before :: ![a]

  A list of elements preceeding the current element.

• _current :: !a

  The current element.

• _after :: ![a]

Instances

Functor NonEmptyZipper

Its a Functor

Methods

fmap :: (a -> b) -> NonEmptyZipper a -> NonEmptyZipper b

(<$) :: a -> NonEmptyZipper b -> NonEmptyZipper a

Applicative NonEmptyZipper

Its Applicative, but pure might not be what you expect

Methods

pure :: a -> NonEmptyZipper a

(<*>) :: NonEmptyZipper (a -> b) -> NonEmptyZipper a -> NonEmptyZipper b

liftA2 :: (a -> b -> c) -> NonEmptyZipper a -> NonEmptyZipper b -> NonEmptyZipper c

(*>) :: NonEmptyZipper a -> NonEmptyZipper b -> NonEmptyZipper b

(<*) :: NonEmptyZipper a -> NonEmptyZipper b -> NonEmptyZipper a

Foldable NonEmptyZipper

Its Foldable

Methods

fold :: Monoid m => NonEmptyZipper m -> m

foldMap :: Monoid m => (a -> m) -> NonEmptyZipper a -> m

foldr :: (a -> b -> b) -> b -> NonEmptyZipper a -> b

foldr' :: (a -> b -> b) -> b -> NonEmptyZipper a -> b

foldl :: (b -> a -> b) -> b -> NonEmptyZipper a -> b

foldl' :: (b -> a -> b) -> b -> NonEmptyZipper a -> b

foldr1 :: (a -> a -> a) -> NonEmptyZipper a -> a

foldl1 :: (a -> a -> a) -> NonEmptyZipper a -> a

toList :: NonEmptyZipper a -> [a]

null :: NonEmptyZipper a -> Bool

length :: NonEmptyZipper a -> Int

elem :: Eq a => a -> NonEmptyZipper a -> Bool

maximum :: Ord a => NonEmptyZipper a -> a

minimum :: Ord a => NonEmptyZipper a -> a

sum :: Num a => NonEmptyZipper a -> a

product :: Num a => NonEmptyZipper a -> a

Traversable NonEmptyZipper

Its Traversable

Methods

traverse :: Applicative f => (a -> f b) -> NonEmptyZipper a -> f (NonEmptyZipper b)

sequenceA :: Applicative f => NonEmptyZipper (f a) -> f (NonEmptyZipper a)

mapM :: Monad m => (a -> m b) -> NonEmptyZipper a -> m (NonEmptyZipper b)

sequence :: Monad m => NonEmptyZipper (m a) -> m (NonEmptyZipper a)

Eq a => Eq (NonEmptyZipper a)

Methods

(==) :: NonEmptyZipper a -> NonEmptyZipper a -> Bool

(/=) :: NonEmptyZipper a -> NonEmptyZipper a -> Bool

Ord a => Ord (NonEmptyZipper a)

Methods

compare :: NonEmptyZipper a -> NonEmptyZipper a -> Ordering

(<) :: NonEmptyZipper a -> NonEmptyZipper a -> Bool

(<=) :: NonEmptyZipper a -> NonEmptyZipper a -> Bool

(>) :: NonEmptyZipper a -> NonEmptyZipper a -> Bool

(>=) :: NonEmptyZipper a -> NonEmptyZipper a -> Bool

max :: NonEmptyZipper a -> NonEmptyZipper a -> NonEmptyZipper a

min :: NonEmptyZipper a -> NonEmptyZipper a -> NonEmptyZipper a

Show a => Show (NonEmptyZipper a)

Methods

showsPrec :: Int -> NonEmptyZipper a -> ShowS

show :: NonEmptyZipper a -> String

showList :: [NonEmptyZipper a] -> ShowS

Semigroup (NonEmptyZipper a)

Its a Semigroup by appending the second NonEmptyZipper to the _after list.

Methods

(<>) :: NonEmptyZipper a -> NonEmptyZipper a -> NonEmptyZipper a

sconcat :: NonEmpty (NonEmptyZipper a) -> NonEmptyZipper a

stimes :: Integral b => b -> NonEmptyZipper a -> NonEmptyZipper a

(|:) :: a -> [a] -> NonEmptyZipper a

Make a NonEmptyZipper from a focus item (which will be the head) and ADDITIONAL options.

nezFromBound :: (Bounded a, Enum a, Eq a) => a -> NonEmptyZipper a

Create a NonEmptyZipper based on a focused item in a Bounded Enum, index position within the Enum will be maintained.

nezFromOptions :: Eq a => a -> [a] -> Maybe (NonEmptyZipper a)

Create a NonEmptyZipper by taking a focused element, and list of options If the focused element is not in the list, we get Nothing.

before :: Functor f => ([a] -> f [a]) -> NonEmptyZipper a -> f (NonEmptyZipper a)

Map to _before, useful as a lens

current :: Functor f => (a -> f a) -> NonEmptyZipper a -> f (NonEmptyZipper a)

Map to current, useful as a lens

after :: Functor f => ([a] -> f [a]) -> NonEmptyZipper a -> f (NonEmptyZipper a)

Map to after, useful as a lens

next :: NonEmptyZipper a -> NonEmptyZipper a

Advance the current element forward by one. If the current is the last element in the list, we do nothing.

nextMod :: NonEmptyZipper a -> NonEmptyZipper a

Advance the current element forward by one. If the current is the last element in the list, we loop back to the first.

previous :: NonEmptyZipper a -> NonEmptyZipper a

Move the current element backward by one. If the current is the first element in the list, we do nothing.

previousMod :: NonEmptyZipper a -> NonEmptyZipper a

Move the current element backward by one. If the current is the first element in the list, we loop to the last element.

toList :: NonEmptyZipper a -> [a]

Convert to a standard list. Current element information will be lost.

fromNonEmpty :: NonEmpty a -> NonEmptyZipper a

Convert from NonEmpty. The first element will be the current element.

inTheBeginning :: NonEmptyZipper a -> Bool

Is the current selection the first item in the collection?

inTheEnd :: NonEmptyZipper a -> Bool

Is the current selection the last item in the collection?

getPosition :: NonEmptyZipper a -> Int

Get the index of the current element in the collection.

length :: NonEmptyZipper a -> Int

Measure the size of the collection. Will be atleast 1.

head :: NonEmptyZipper a -> a

Get the first element out of the NonEmptyZipper.

init :: NonEmptyZipper a -> Maybe (NonEmptyZipper a)

Get all elements out of the NonEmptyZipper that are not the last element. If there is only one element in the collection, it's Nothing.

last :: NonEmptyZipper a -> a

Get the last element out of the NonEmptyZipper.

tail :: NonEmptyZipper a -> Maybe (NonEmptyZipper a)

Get all elements out of the NonEmptyZipper that are not the first element. If there is only one element in the collection, its Nothing.

reverse :: NonEmptyZipper a -> NonEmptyZipper a

Flip the NonEmptyZipper, maintaining the current element.

cons :: a -> NonEmptyZipper a -> NonEmptyZipper a

Add one element to the front of a NonEmptyZipper.

wrap :: a -> NonEmptyZipper a

This is like pure but more intuitive. The Applicative instance for NonEmptyZipper is likely not what you expect.

setCurrent :: Eq a => a -> NonEmptyZipper a -> Maybe (NonEmptyZipper a)

Set the current element in the NonEmptyZipper. If the element does not appear in the collection, the result with be Nothing

setCurrentIndex :: Int -> NonEmptyZipper a -> Maybe (NonEmptyZipper a)

Set the current element in the NonEmptyZipper via index location. If the index is out of bounds the results will be Nothing.