- data Cycle a
- goLeft :: Cycle a -> Cycle a
- goRight :: Cycle a -> Cycle a
- goLR :: Int -> Cycle a -> Cycle a
- getValue :: Cycle a -> a
- leftValue :: Cycle a -> a
- rightValue :: Cycle a -> a
- nthValue :: Int -> Cycle a -> a
- takeLR :: Int -> Cycle a -> [a]
- dropLR :: Int -> Cycle a -> [a]
- cycleToInfiniteList :: Cycle a -> [a]
- zipCycle :: Cycle a -> Cycle b -> Cycle (a, b)
- zipCycleWith :: (a -> b -> c) -> Cycle a -> Cycle b -> Cycle c

# Documentation

A cyclic doubly linked list.

To create a new Cycle, use
`fromList`

, `fromFoldable`

or any of
the insertion functions from `Unfoldable`

. Elements
are inserted in front of the current position.

To get the length of the list, use `size`

.
To extract all cycle elements, use `toList`

. You can
also create an infinite list with `cycleToInfiniteList`

.

The functions `front`

and `back`

fail with `error`

for empty cycles.

`take`

, `drop`

and
`splitAt`

fail with `error`

for empty cycles if their
first argument is not 0. They also accept negative values for working
backwards (see `takeLR`

and `dropLR`

for details).

In general, any function `f`

working on
`[a]`

can be adapted for `Cycle a`

by writing `fromList . f . toList`

.

The `Monad`

, `Functor`

, `Applicative`

, `Alternative`

, `Monoid`

and
`Foldable`

instances work
like the default instances for lists.

goRight :: Cycle a -> Cycle aSource

Move focus to the element on the right of the current position.

goLeft . goRight == id

goLR :: Int -> Cycle a -> Cycle aSource

Move `abs n`

steps to the left (`n < 0`

) or right (`n > 0`

) or don't move
at all (`n == 0`

).

rightValue :: Cycle a -> aSource

Get value on the right. `error`

if `null c`

.

nthValue :: Int -> Cycle a -> aSource

Get nth value to the left (`n < 0`

) or right (`n > 0`

) or
the current value (`n == 0`

). `error`

if `null c`

.

nthValue = flip (!)

takeLR :: Int -> Cycle a -> [a]Source

Take `abs n`

values starting at the current one and moving
to the right (`n > 0`

) or left (`n < 0`

). `n`

can be arbitrary
big.

take n = fromList . takeLR n

dropLR :: Int -> Cycle a -> [a]Source

Drop `abs n`

values starting at the current one and moving
to the right (`n > 0`

) or left (`n < 0`

). `n`

can be arbitrary
big.

drop n = fromList . dropLR n

cycleToInfiniteList :: Cycle a -> [a]Source

Convert to an infinite list starting with the current value and moving to the right.

zipCycleWith :: (a -> b -> c) -> Cycle a -> Cycle b -> Cycle cSource

Combine to cycles by applying a binary function to all element
pairs. Like `Data.List.zipWith`

.