Data.GroupedList

Grouped lists are like lists, but internally they are represented as groups of consecutive elements.

For example, the list [1,2,2,3,4,5,5,5] would be internally represented as [[1],[2,2],[3],[4],[5,5,5]].

Type

data Grouped a

Type of grouped lists. Grouped lists are finite lists that behave well in the abundance of sublists that have all their elements equal.

Instances

Foldable Grouped

Pointed Grouped

Eq a => Eq (Grouped a)

Show a => Show (Grouped a)

Eq a => Monoid (Grouped a)

NFData a => NFData (Grouped a)

Builders

point :: Pointed p => forall a. a -> p a

concatMap :: Eq b => Grouped a -> (a -> Grouped b) -> Grouped b

Map a function that produces a grouped list for each element in a grouped list, then concat the results.

replicate :: Int -> a -> Grouped a

Replicate a single element the given number of times. If the given number is less or equal to zero, it produces an empty list.

fromGroup :: Group a -> Grouped a

Build a grouped list from a group (see Group).

Indexing

index :: Grouped a -> Int -> Maybe a

Retrieve the element at the given index. If the index is out of the list index range, it returns Nothing.

adjust :: Eq a => (a -> a) -> Int -> Grouped a -> Grouped a

Update the element at the given index. If the index is out of range, the original list is returned.

Mapping

map :: Eq b => (a -> b) -> Grouped a -> Grouped b

Apply a function to every element in a grouped list.

Traversal

traverseGrouped :: (Applicative f, Eq b) => (a -> f b) -> Grouped a -> f (Grouped b)

Apply a function with results residing in an applicative functor to every element in a grouped list.

traverseGroupedByGroup :: (Applicative f, Eq b) => (Group a -> f (Grouped b)) -> Grouped a -> f (Grouped b)

Similar to traverseGrouped, but instead of applying a function to every element of the list, it is applied to groups of consecutive elements. You might return more than one element, so the result is of type Grouped. The results are then concatenated into a single value, embedded in the applicative functor.

traverseGroupedByGroupAccum

Arguments

:: (Monad m, Eq b)

=> (acc -> Group a -> m (acc, Grouped b))

-> acc

Initial value of the accumulator.

-> Grouped a

-> m (acc, Grouped b)

Like traverseGroupedByGroup, but carrying an accumulator. Note the Monad constraint instead of Applicative.

Filtering

partition :: Eq a => (a -> Bool) -> Grouped a -> (Grouped a, Grouped a)

Break a grouped list in the elements that match a given condition and those that don't.

filter :: Eq a => (a -> Bool) -> Grouped a -> Grouped a

Filter a grouped list by keeping only those that match a given condition.

Sorting

sort :: Ord a => Grouped a -> Grouped a

Sort a grouped list.

List conversion

fromList :: Eq a => [a] -> Grouped a

Build a grouped list from a regular list. It doesn't work if the input list is infinite.

Groups

data Group a

A Group is a non-empty finite list that contains the same element repeated a number of times.

Instances

Monad Group

Functor Group

Applicative Group

Foldable Group

Pointed Group

Eq a => Eq (Group a)

Ord a => Ord (Group a)

A group is larger than other if its constituent element is larger. If they are equal, the group with more elements is the larger.

Show a => Show (Group a)

NFData a => NFData (Group a)

buildGroup :: Int -> a -> Maybe (Group a)

Build a group by repeating the given element a number of times. If the given number is less or equal to 0, Nothing is returned.

groupElement :: Group a -> a

Get the element of a group.

groupedGroups :: Grouped a -> [Group a]

Groups of consecutive elements in a grouped list.