Data.CircularList.Internal

Documentation

data CList a

A functional ring type.

Constructors

Empty

CList [a] a [a]

Instances

Functor CList

Defined in Data.CircularList.Internal

Methods

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

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

Foldable CList

Defined in Data.CircularList.Internal

Methods

fold :: Monoid m => CList m -> m

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

foldMap' :: Monoid m => (a -> m) -> CList a -> m

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

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

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

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

foldr1 :: (a -> a -> a) -> CList a -> a

foldl1 :: (a -> a -> a) -> CList a -> a

toList :: CList a -> [a]

null :: CList a -> Bool

length :: CList a -> Int

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

maximum :: Ord a => CList a -> a

minimum :: Ord a => CList a -> a

sum :: Num a => CList a -> a

product :: Num a => CList a -> a

Traversable CList

Defined in Data.CircularList.Internal

Methods

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

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

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

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

Eq a => Eq (CList a)

Defined in Data.CircularList.Internal

Methods

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

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

Read a => Read (CList a)

Defined in Data.CircularList.Internal

Methods

readsPrec :: Int -> ReadS (CList a)

readList :: ReadS [CList a]

readPrec :: ReadPrec (CList a)

readListPrec :: ReadPrec [CList a]

Show a => Show (CList a)

Defined in Data.CircularList.Internal

Methods

showsPrec :: Int -> CList a -> ShowS

show :: CList a -> String

showList :: [CList a] -> ShowS

NFData a => NFData (CList a)

Defined in Data.CircularList.Internal

Methods

rnf :: CList a -> ()

empty :: CList a

An empty CList.

fromList :: [a] -> CList a

Make a (balanced) CList from a list.

singleton :: a -> CList a

update :: a -> CList a -> CList a

Replaces the current focus with a new focus.

reverseDirection :: CList a -> CList a

Reverse the direction of rotation.

leftElements :: CList a -> [a]

Starting with the focus, go left and accumulate all elements of the CList in a list.

rightElements :: CList a -> [a]

Starting with the focus, go right and accumulate all elements of the CList in a list.

toList :: CList a -> [a]

Make a list from a CList.

toInfList :: CList a -> [a]

Make a CList into an infinite list.

focus :: CList a -> Maybe a

Return the focus of the CList.

insertR :: a -> CList a -> CList a

Insert an element into the CList as the new focus. The old focus is now the next element to the right.

insertL :: a -> CList a -> CList a

Insert an element into the CList as the new focus. The old focus is now the next element to the left.

removeL :: CList a -> CList a

Remove the focus from the CList. The new focus is the next element to the left.

removeR :: CList a -> CList a

Remove the focus from the CList.

allRotations :: CList a -> CList (CList a)

Return all possible rotations of the provided CList, where the focus is the provided CList.

rotL :: CList a -> CList a

Rotate the focus to the previous (left) element.

mRotL :: CList a -> Maybe (CList a)

A non-cyclic version of rotL; that is, only rotate the focus if there is a previous (left) element to rotate to.

rotR :: CList a -> CList a

Rotate the focus to the next (right) element.

mRotR :: CList a -> Maybe (CList a)

A non-cyclic version of rotL; that is, only rotate the focus if there is a previous (left) element to rotate to.

rotN :: Int -> CList a -> CList a

Rotate the focus the specified number of times; if the index is positive then it is rotated to the right; otherwise it is rotated to the left.

rotNR :: Int -> CList a -> CList a

A wrapper around rotN that doesn't rotate the CList if n <= 0.

rotNL :: Int -> CList a -> CList a

Rotate the focus the specified number of times to the left (but don't rotate if n <= 0).

rotateTo :: Eq a => a -> CList a -> Maybe (CList a)

Rotate the CList such that the specified element (if it exists) is focused.

findRotateTo :: (a -> Bool) -> CList a -> Maybe (CList a)

Attempt to rotate the CList such that focused element matches the supplied predicate.

filterR :: (a -> Bool) -> CList a -> CList a

Remove those elements that do not satisfy the supplied predicate, rotating to the right if the focus does not satisfy the predicate.

filterL :: (a -> Bool) -> CList a -> CList a

As with filterR, but rotates to the left if the focus does not satisfy the predicate.

filterCL :: (CList a -> CList a) -> (a -> Bool) -> CList a -> CList a

Abstract away what to do with the focused element if it doesn't match the predicate when filtering.

foldrR :: (a -> b -> b) -> b -> CList a -> b

A right-fold, rotating to the right through the CList.

foldrL :: (a -> b -> b) -> b -> CList a -> b

A right-fold, rotating to the left through the CList.

foldrCL :: (CList a -> [a]) -> (a -> b -> b) -> b -> CList a -> b

Abstract away direction for a foldr.

foldlR :: (a -> b -> a) -> a -> CList b -> a

A (strict) left-fold, rotating to the right through the CList.

foldlL :: (a -> b -> a) -> a -> CList b -> a

A (strict) left-fold, rotating to the left through the CList.

foldlCL :: (CList b -> [b]) -> (a -> b -> a) -> a -> CList b -> a

Abstract away direction for a foldl'.

balance :: CList a -> CList a

Balance the CList. Equivalent to `fromList . toList`

packL :: CList a -> CList a

Move all elements to the left side of the CList.

packR :: CList a -> CList a

Move all elements to the right side of the CList.

isEmpty :: CList a -> Bool

Returns true if the CList is empty.

size :: CList a -> Int

Return the size of the CList.