Safe Haskell | Safe |
---|---|
Language | Haskell2010 |
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]]
.
- data Grouped a
- empty :: Grouped a
- point :: Pointed p => forall a. a -> p a
- concatMap :: Eq b => Grouped a -> (a -> Grouped b) -> Grouped b
- replicate :: Int -> a -> Grouped a
- fromGroup :: Group a -> Grouped a
- index :: Grouped a -> Int -> Maybe a
- adjust :: Eq a => (a -> a) -> Int -> Grouped a -> Grouped a
- adjustM :: (Monad m, Eq a) => (a -> m a) -> Int -> Grouped a -> m (Grouped a)
- map :: Eq b => (a -> b) -> Grouped a -> Grouped b
- traverseGrouped :: (Applicative f, Eq b) => (a -> f b) -> Grouped a -> f (Grouped b)
- traverseGroupedByGroup :: (Applicative f, Eq b) => (Group a -> f (Grouped b)) -> Grouped a -> f (Grouped b)
- traverseGroupedByGroupAccum :: (Monad m, Eq b) => (acc -> Group a -> m (acc, Grouped b)) -> acc -> Grouped a -> m (acc, Grouped b)
- partition :: Eq a => (a -> Bool) -> Grouped a -> (Grouped a, Grouped a)
- filter :: Eq a => (a -> Bool) -> Grouped a -> Grouped a
- sort :: Ord a => Grouped a -> Grouped a
- fromList :: Eq a => [a] -> Grouped a
- data Group a
- buildGroup :: Int -> a -> Maybe (Group a)
- groupElement :: Group a -> a
- groupedGroups :: Grouped a -> [Group a]
Type
Type of grouped lists. Grouped lists are finite lists that behave well in the abundance of sublists that have all their elements equal.
Builders
concatMap :: Eq b => Grouped a -> (a -> Grouped b) -> Grouped b Source
Map a function that produces a grouped list for each element in a grouped list, then concat the results.
replicate :: Int -> a -> Grouped a Source
Replicate a single element the given number of times. If the given number is less or equal to zero, it produces an empty list.
Indexing
index :: Grouped a -> Int -> Maybe a Source
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 Source
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 Source
Apply a function to every element in a grouped list.
Traversal
traverseGrouped :: (Applicative f, Eq b) => (a -> f b) -> Grouped a -> f (Grouped b) Source
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) Source
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 Source
:: (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) Source
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 Source
Filter a grouped list by keeping only those that match a given condition.
Sorting
List conversion
fromList :: Eq a => [a] -> Grouped a Source
Build a grouped list from a regular list. It doesn't work if the input list is infinite.
Groups
A Group
is a non-empty finite list that contains the same element
repeated a number of times.
Monad Group Source | |
Functor Group Source | |
Applicative Group Source | |
Foldable Group Source | |
Pointed Group Source | |
Eq a => Eq (Group a) Source | |
Ord a => Ord (Group a) Source | 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) Source | |
NFData a => NFData (Group a) Source |
buildGroup :: Int -> a -> Maybe (Group a) Source
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 Source
Get the element of a group.
groupedGroups :: Grouped a -> [Group a] Source
Groups of consecutive elements in a grouped list.