Safe Haskell	None
Language	Haskell2010

Data.GroupedList

Contents

Type
Builders
Info
Indexing
Sublists
Mapping
Traversal
Filtering
Sorting
Zipping
List conversion
Groups
- In grouped lists

Description

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]]. Use groupedGroups to see this.

Synopsis

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 #
Methods fold :: Monoid m => Grouped m -> m # foldMap :: Monoid m => (a -> m) -> Grouped a -> m # foldr :: (a -> b -> b) -> b -> Grouped a -> b # foldr' :: (a -> b -> b) -> b -> Grouped a -> b # foldl :: (b -> a -> b) -> b -> Grouped a -> b # foldl' :: (b -> a -> b) -> b -> Grouped a -> b # foldr1 :: (a -> a -> a) -> Grouped a -> a # foldl1 :: (a -> a -> a) -> Grouped a -> a # toList :: Grouped a -> [a] # null :: Grouped a -> Bool # length :: Grouped a -> Int # elem :: Eq a => a -> Grouped a -> Bool # maximum :: Ord a => Grouped a -> a # minimum :: Ord a => Grouped a -> a # sum :: Num a => Grouped a -> a # product :: Num a => Grouped a -> a #
Pointed Grouped #
Methods point :: a -> Grouped a #
Eq a => IsList (Grouped a) #	Method `fromList` doesn't work for infinite lists. A grouped list cannot be infinite.
Associated Types type Item (Grouped a) :: * # Methods fromList :: [Item (Grouped a)] -> Grouped a # fromListN :: Int -> [Item (Grouped a)] -> Grouped a # toList :: Grouped a -> [Item (Grouped a)] #
Eq a => Eq (Grouped a) #
Methods (==) :: Grouped a -> Grouped a -> Bool # (/=) :: Grouped a -> Grouped a -> Bool #
Show a => Show (Grouped a) #
Methods showsPrec :: Int -> Grouped a -> ShowS # show :: Grouped a -> String # showList :: [Grouped a] -> ShowS #
Eq a => Monoid (Grouped a) #
Methods mempty :: Grouped a # mappend :: Grouped a -> Grouped a -> Grouped a # mconcat :: [Grouped a] -> Grouped a #
NFData a => NFData (Grouped a) #
Methods rnf :: Grouped a -> () #
type Item (Grouped a) #
type Item (Grouped a) = a

Builders

empty :: Grouped a #

Grouped list with no elements.

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

Use point to create a Grouped list with a single element.

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).

Info

length :: Foldable t => forall a. t a -> Int #

Returns the size/length of a finite structure as an Int. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.

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.

adjustM :: (Monad m, Eq a) => (a -> m a) -> Int -> Grouped a -> m (Grouped a) #

Just like adjust, but the function returns in a Monad.

Sublists

take :: Int -> Grouped a -> Grouped a #

Take the given number of elements from the left end of the list.

drop :: Int -> Grouped a -> Grouped a #

Discard the given number of elements from the left end of the list.

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 elements that match a given condition.

Sorting

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

Sort a grouped list.

Zipping

zipWith :: Eq c => (a -> b -> c) -> Grouped a -> Grouped b -> Grouped c #

Combine two lists using a combining function. If one list is longer, remaining elements are discarded.

zip :: (Eq a, Eq b) => Grouped a -> Grouped b -> Grouped (a, b) #

Combine two lists in a single list of pairs. If one list is longer, remaining elements are discarded.

List conversion

For to-list conversion use toList.

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 #
Methods (>>=) :: Group a -> (a -> Group b) -> Group b # (>>) :: Group a -> Group b -> Group b # return :: a -> Group a # fail :: String -> Group a #
Functor Group #
Methods fmap :: (a -> b) -> Group a -> Group b # (<$) :: a -> Group b -> Group a #
Applicative Group #
Methods pure :: a -> Group a # (<>) :: Group (a -> b) -> Group a -> Group b # (>) :: Group a -> Group b -> Group b # (<*) :: Group a -> Group b -> Group a #
Foldable Group #
Methods fold :: Monoid m => Group m -> m # foldMap :: Monoid m => (a -> m) -> Group a -> m # foldr :: (a -> b -> b) -> b -> Group a -> b # foldr' :: (a -> b -> b) -> b -> Group a -> b # foldl :: (b -> a -> b) -> b -> Group a -> b # foldl' :: (b -> a -> b) -> b -> Group a -> b # foldr1 :: (a -> a -> a) -> Group a -> a # foldl1 :: (a -> a -> a) -> Group a -> a # toList :: Group a -> [a] # null :: Group a -> Bool # length :: Group a -> Int # elem :: Eq a => a -> Group a -> Bool # maximum :: Ord a => Group a -> a # minimum :: Ord a => Group a -> a # sum :: Num a => Group a -> a # product :: Num a => Group a -> a #
Pointed Group #
Methods point :: a -> Group a #
Eq a => Eq (Group a) #
Methods (==) :: Group a -> Group a -> Bool # (/=) :: Group a -> Group a -> Bool #
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.
Methods compare :: Group a -> Group a -> Ordering # (<) :: Group a -> Group a -> Bool # (<=) :: Group a -> Group a -> Bool # (>) :: Group a -> Group a -> Bool # (>=) :: Group a -> Group a -> Bool # max :: Group a -> Group a -> Group a # min :: Group a -> Group a -> Group a #
Show a => Show (Group a) #
Methods showsPrec :: Int -> Group a -> ShowS # show :: Group a -> String # showList :: [Group a] -> ShowS #
NFData a => NFData (Group a) #
Methods rnf :: 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.

groupSize :: Group a -> Int #

Size of a group.

In grouped lists

groupedGroups :: Grouped a -> [Group a] #

Groups of consecutive elements in a grouped list.

firstGroup :: Grouped a -> Maybe (Group a, Grouped a) #

Get the first group (if the list is not empty) and the rest of the list.

lastGroup :: Grouped a -> Maybe (Grouped a, Group a) #

Get the last group (if the list is not empty) and the rest of the list.