| License | BSD-style |
|---|---|
| Maintainer | Vincent Hanquez <vincent@snarc.org> |
| Stability | experimental |
| Portability | portable |
| Safe Haskell | None |
| Language | Haskell2010 |
Foundation.Collection
Description
Different collections (list, vector, string, ..) unified under 1 API. an API to rules them all, and in the darkness bind them.
- class Zippable col => BoxedZippable col where
- type family Element container
- class InnerFunctor c where
- class Foldable collection where
- class Foldable f => Fold1able f where
- class Functor collection => Mappable collection where
- traverse_ :: (Mappable col, Applicative f) => (a -> f b) -> col a -> f ()
- mapM_ :: (Mappable col, Applicative m, Monad m) => (a -> m b) -> col a -> m ()
- forM :: (Mappable col, Applicative m, Monad m) => col a -> (a -> m b) -> m (col b)
- forM_ :: (Mappable col, Applicative m, Monad m) => col a -> (a -> m b) -> m ()
- class (IsList c, Item c ~ Element c) => Collection c where
- and :: (Collection col, Element col ~ Bool) => col -> Bool
- or :: (Collection col, Element col ~ Bool) => col -> Bool
- data NonEmpty a :: * -> *
- getNonEmpty :: NonEmpty a -> a
- nonEmpty :: Collection c => c -> Maybe (NonEmpty c)
- nonEmpty_ :: Collection c => c -> NonEmpty c
- nonEmptyFmap :: Functor f => (a -> b) -> NonEmpty (f a) -> NonEmpty (f b)
- class (IsList c, Item c ~ Element c, Monoid c, Collection c) => Sequential c where
- class MutableCollection c where
- type MutableFreezed c
- type MutableKey c
- type MutableValue c
- class IndexedCollection c where
- class KeyedCollection c where
- class Sequential col => Zippable col where
- class Buildable col where
- build_ :: (Buildable c, PrimMonad prim) => Int -> Builder c (Mutable c) (Step c) prim () () -> prim c
- newtype Builder collection mutCollection step state err a :: * -> (* -> *) -> * -> (* -> *) -> * -> * -> * = Builder {
- runBuilder :: State (Offset step, BuildingState collection mutCollection step (PrimState state), Maybe err) state a
- data BuildingState collection mutCollection step state :: * -> (* -> *) -> * -> * -> * = BuildingState {
- prevChunks :: [collection]
- prevChunksSize :: ~(CountOf step)
- curChunk :: mutCollection state
- chunkSize :: ~(CountOf step)
- class Copy a where
Documentation
class Zippable col => BoxedZippable col where #
Methods
zip :: (Sequential a, Sequential b, Element col ~ (Element a, Element b)) => a -> b -> col #
zip takes two collections and returns a collections of corresponding
pairs. If one input collection is short, excess elements of the longer
collection are discarded.
zip3 :: (Sequential a, Sequential b, Sequential c, Element col ~ (Element a, Element b, Element c)) => a -> b -> c -> col #
Like zip, but works with 3 collections.
zip4 :: (Sequential a, Sequential b, Sequential c, Sequential d, Element col ~ (Element a, Element b, Element c, Element d)) => a -> b -> c -> d -> col #
Like zip, but works with 4 collections.
zip5 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Element col ~ (Element a, Element b, Element c, Element d, Element e)) => a -> b -> c -> d -> e -> col #
Like zip, but works with 5 collections.
zip6 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Element col ~ (Element a, Element b, Element c, Element d, Element e, Element f)) => a -> b -> c -> d -> e -> f -> col #
Like zip, but works with 6 collections.
zip7 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Sequential g, Element col ~ (Element a, Element b, Element c, Element d, Element e, Element f, Element g)) => a -> b -> c -> d -> e -> f -> g -> col #
Like zip, but works with 7 collections.
unzip :: (Sequential a, Sequential b, Element col ~ (Element a, Element b)) => col -> (a, b) #
unzip transforms a collection of pairs into a collection of first
components and a collection of second components.
unzip3 :: (Sequential a, Sequential b, Sequential c, Element col ~ (Element a, Element b, Element c)) => col -> (a, b, c) #
Like unzip, but works on a collection of 3-element tuples.
unzip4 :: (Sequential a, Sequential b, Sequential c, Sequential d, Element col ~ (Element a, Element b, Element c, Element d)) => col -> (a, b, c, d) #
Like unzip, but works on a collection of 4-element tuples.
unzip5 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Element col ~ (Element a, Element b, Element c, Element d, Element e)) => col -> (a, b, c, d, e) #
Like unzip, but works on a collection of 5-element tuples.
unzip6 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Element col ~ (Element a, Element b, Element c, Element d, Element e, Element f)) => col -> (a, b, c, d, e, f) #
Like unzip, but works on a collection of 6-element tuples.
unzip7 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Sequential g, Element col ~ (Element a, Element b, Element c, Element d, Element e, Element f, Element g)) => col -> (a, b, c, d, e, f, g) #
Like unzip, but works on a collection of 7-element tuples.
Instances
| BoxedZippable [a] # | |
| BoxedZippable (Array ty) # | |
class InnerFunctor c where #
A monomorphic functor that maps the inner values to values of the same type
Methods
imap :: (Element c -> Element c) -> c -> c #
imap :: (Functor f, Element (f a) ~ a, f a ~ c) => (Element c -> Element c) -> c -> c #
Instances
| InnerFunctor String # | |
| InnerFunctor Bitmap # | |
| InnerFunctor [a] # | |
| InnerFunctor (Array ty) # | |
| PrimType ty => InnerFunctor (UArray ty) # | |
class Foldable collection where #
Give the ability to fold a collection on itself
Methods
foldl' :: (a -> Element collection -> a) -> a -> collection -> a #
Left-associative fold of a structure.
In the case of lists, foldl, when applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:
foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn
Note that to produce the outermost application of the operator the entire input list must be traversed. This means that foldl' will diverge if given an infinite list.
Note that Foundation only provides foldl', a strict version of foldl because
the lazy version is seldom useful.
Left-associative fold of a structure with strict application of the operator.
foldr :: (Element collection -> a -> a) -> a -> collection -> a #
Right-associative fold of a structure.
foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)
foldr' :: (Element collection -> a -> a) -> a -> collection -> a #
Right-associative fold of a structure, but with strict application of the operator.
class Foldable f => Fold1able f where #
Fold1's. Like folds, but they assume to operate on a NonEmpty collection.
class Functor collection => Mappable collection where #
Functors representing data structures that can be traversed from left to right.
Mostly like base's Traversable but applied to collections only.
Methods
traverse :: Applicative f => (a -> f b) -> collection a -> f (collection b) #
Map each element of a structure to an action, evaluate these actions
from left to right, and collect the results. For a version that ignores
the results see traverse_.
sequenceA :: Applicative f => collection (f a) -> f (collection a) #
Evaluate each actions of the given collections, from left to right,
and collect the results. For a version that ignores the results, see
sequenceA_
mapM :: (Applicative m, Monad m) => (a -> m b) -> collection a -> m (collection b) #
Map each element of the collection to an action, evaluate these actions
from left to right, and collect the results. For a version that ignores
the results see mapM_.
sequence :: (Applicative m, Monad m) => collection (m a) -> m (collection a) #
Evaluate each actions of the given collections, from left to right,
and collect the results. For a version that ignores the results, see
sequence_
traverse_ :: (Mappable col, Applicative f) => (a -> f b) -> col a -> f () #
Map each element of a collection to an action, evaluate these
actions from left to right, and ignore the results. For a version
that doesn't ignore the results see traverse
mapM_ :: (Mappable col, Applicative m, Monad m) => (a -> m b) -> col a -> m () #
Evaluate each action in the collection from left to right, and
ignore the results. For a version that doesn't ignore the results
see sequenceA.
sequenceA_ :: (Mappable col, Applicative f) => col (f a) -> f ()
sequenceA_ col = sequenceA col *> pure ()
Map each element of a collection to a monadic action, evaluate
these actions from left to right, and ignore the results. For a
version that doesn't ignore the results see
mapM.
forM :: (Mappable col, Applicative m, Monad m) => col a -> (a -> m b) -> m (col b) #
forM_ :: (Mappable col, Applicative m, Monad m) => col a -> (a -> m b) -> m () #
class (IsList c, Item c ~ Element c) => Collection c where #
A set of methods for ordered colection
Methods
Check if a collection is empty
length :: c -> CountOf (Element c) #
Length of a collection (number of Element c)
elem :: forall a. (Eq a, a ~ Element c) => Element c -> c -> Bool #
Check if a collection contains a specific element
This is the inverse of notElem.
notElem :: forall a. (Eq a, a ~ Element c) => Element c -> c -> Bool #
Check if a collection does *not* contain a specific element
This is the inverse of elem.
maximum :: forall a. (Ord a, a ~ Element c) => NonEmpty c -> Element c #
Get the maximum element of a collection
minimum :: forall a. (Ord a, a ~ Element c) => NonEmpty c -> Element c #
Get the minimum element of a collection
any :: (Element c -> Bool) -> c -> Bool #
Determine is any elements of the collection satisfy the predicate
all :: (Element c -> Bool) -> c -> Bool #
Determine is all elements of the collection satisfy the predicate
Instances
| Collection String # | |
| Collection AsciiString # | |
| Collection Bitmap # | |
| Collection [a] # | |
| Collection (Array ty) # | |
| PrimType ty => Collection (UArray ty) # | |
| PrimType ty => Collection (Block ty) # | |
| Collection c => Collection (NonEmpty c) # | |
| Collection (DList a) # | |
| PrimType ty => Collection (ChunkedUArray ty) # | |
and :: (Collection col, Element col ~ Bool) => col -> Bool #
Return True if all the elements in the collection are True
or :: (Collection col, Element col ~ Bool) => col -> Bool #
Return True if at least one element in the collection is True
NonEmpty property for any Collection
getNonEmpty :: NonEmpty a -> a #
nonEmpty :: Collection c => c -> Maybe (NonEmpty c) #
Smart constructor to create a NonEmpty collection
If the collection is empty, then Nothing is returned Otherwise, the collection is wrapped in the NonEmpty property
nonEmpty_ :: Collection c => c -> NonEmpty c #
same as nonEmpty, but assume that the collection is non empty,
and return an asynchronous error if it is.
nonEmptyFmap :: Functor f => (a -> b) -> NonEmpty (f a) -> NonEmpty (f b) #
class (IsList c, Item c ~ Element c, Monoid c, Collection c) => Sequential c where #
A set of methods for ordered colection
Methods
take :: CountOf (Element c) -> c -> c #
Take the first @n elements of a collection
revTake :: CountOf (Element c) -> c -> c #
Take the last @n elements of a collection
drop :: CountOf (Element c) -> c -> c #
Drop the first @n elements of a collection
revDrop :: CountOf (Element c) -> c -> c #
Drop the last @n elements of a collection
splitAt :: CountOf (Element c) -> c -> (c, c) #
Split the collection at the @n'th elements
revSplitAt :: CountOf (Element c) -> c -> (c, c) #
Split the collection at the @n'th elements from the end
splitOn :: (Element c -> Bool) -> c -> [c] #
Split on a specific elements returning a list of colletion
break :: (Element c -> Bool) -> c -> (c, c) #
Split a collection when the predicate return true
breakEnd :: (Element c -> Bool) -> c -> (c, c) #
Split a collection when the predicate return true
breakElem :: Eq (Element c) => Element c -> c -> (c, c) #
Split a collection when the predicate return true starting from the end of the collection
takeWhile :: (Element c -> Bool) -> c -> c #
Return the longest prefix in the collection that satisfy the predicate
dropWhile :: (Element c -> Bool) -> c -> c #
Return the longest prefix in the collection that satisfy the predicate
intersperse :: Element c -> c -> c #
The intersperse function takes an element and a list and
`intersperses' that element between the elements of the list.
For example,
intersperse ',' "abcde" == "a,b,c,d,e"
intercalate :: Monoid (Item c) => Element c -> c -> Element c #
intercalate xs xss is equivalent to (.
It inserts the list mconcat (intersperse xs xss))xs in between the lists in xss and concatenates the
result.
span :: (Element c -> Bool) -> c -> (c, c) #
Split a collection while the predicate return true
spanEnd :: (Element c -> Bool) -> c -> (c, c) #
Split a collection while the predicate return true starting from the end of the collection
filter :: (Element c -> Bool) -> c -> c #
Filter all the elements that satisfy the predicate
partition :: (Element c -> Bool) -> c -> (c, c) #
Partition the elements thtat satisfy the predicate and those that don't
Reverse a collection
uncons :: c -> Maybe (Element c, c) #
Decompose a collection into its first element and the remaining collection. If the collection is empty, returns Nothing.
unsnoc :: c -> Maybe (c, Element c) #
Decompose a collection into a collection without its last element, and the last element If the collection is empty, returns Nothing.
Prepend an element to an ordered collection
Append an element to an ordered collection
find :: (Element c -> Bool) -> c -> Maybe (Element c) #
Find an element in an ordered collection
sortBy :: (Element c -> Element c -> Ordering) -> c -> c #
Sort an ordered collection using the specified order function
Create a collection with a single element
head :: NonEmpty c -> Element c #
get the first element of a non-empty collection
last :: NonEmpty c -> Element c #
get the last element of a non-empty collection
Extract the elements after the first element of a non-empty collection.
Extract the elements before the last element of a non-empty collection.
replicate :: CountOf (Element c) -> Element c -> c #
Create a collection where the element in parameter is repeated N time
isPrefixOf :: Eq (Element c) => c -> c -> Bool #
Takes two collections and returns True iff the first collection is a prefix of the second.
isPrefixOf :: Eq c => c -> c -> Bool #
Takes two collections and returns True iff the first collection is a prefix of the second.
isSuffixOf :: Eq (Element c) => c -> c -> Bool #
Takes two collections and returns True iff the first collection is a suffix of the second.
isSuffixOf :: Eq c => c -> c -> Bool #
Takes two collections and returns True iff the first collection is a suffix of the second.
isInfixOf :: Eq (Element c) => c -> c -> Bool #
Takes two collections and returns True iff the first collection is an infix of the second.
isInfixOf :: Eq c => c -> c -> Bool #
Takes two collections and returns True iff the first collection is an infix of the second.
stripPrefix :: Eq (Element c) => c -> c -> Maybe c #
Try to strip a prefix from a collection
stripSuffix :: Eq (Element c) => c -> c -> Maybe c #
Try to strip a suffix from a collection
Instances
| Sequential String # | |
| Sequential AsciiString # | |
| Sequential Bitmap # | |
| Sequential [a] # | |
| Sequential (Array ty) # | |
| PrimType ty => Sequential (UArray ty) # | |
| PrimType ty => Sequential (Block ty) # | |
| Sequential (DList a) # | |
| PrimType ty => Sequential (ChunkedUArray ty) # | |
class MutableCollection c where #
Collection of things that can be made mutable, modified and then freezed into an MutableFreezed collection
Minimal complete definition
thaw, freeze, mutNew, mutWrite, mutRead, mutUnsafeWrite, mutUnsafeRead
Methods
unsafeThaw :: PrimMonad prim => MutableFreezed c -> prim (c (PrimState prim)) #
unsafeFreeze :: PrimMonad prim => c (PrimState prim) -> prim (MutableFreezed c) #
thaw :: PrimMonad prim => MutableFreezed c -> prim (c (PrimState prim)) #
freeze :: PrimMonad prim => c (PrimState prim) -> prim (MutableFreezed c) #
mutNew :: PrimMonad prim => CountOf (MutableValue c) -> prim (c (PrimState prim)) #
mutUnsafeWrite :: PrimMonad prim => c (PrimState prim) -> MutableKey c -> MutableValue c -> prim () #
mutWrite :: PrimMonad prim => c (PrimState prim) -> MutableKey c -> MutableValue c -> prim () #
mutUnsafeRead :: PrimMonad prim => c (PrimState prim) -> MutableKey c -> prim (MutableValue c) #
mutRead :: PrimMonad prim => c (PrimState prim) -> MutableKey c -> prim (MutableValue c) #
Instances
| MutableCollection MutableBitmap # | |
| MutableCollection (MArray ty) # | |
| PrimType ty => MutableCollection (MUArray ty) # | |
| PrimType ty => MutableCollection (MutableBlock ty) # | |
class IndexedCollection c where #
Collection of elements that can indexed by int
Methods
(!) :: c -> Offset (Element c) -> Maybe (Element c) #
findIndex :: (Element c -> Bool) -> c -> Maybe (Offset (Element c)) #
Instances
| IndexedCollection String # | |
| IndexedCollection Bitmap # | |
| IndexedCollection [a] # | |
| IndexedCollection (Array ty) # | |
| PrimType ty => IndexedCollection (UArray ty) # | |
| PrimType ty => IndexedCollection (Block ty) # | |
| PrimType ty => IndexedCollection (ChunkedUArray ty) # | |
class KeyedCollection c where #
Collection of things that can be looked up by Key
Minimal complete definition
Instances
| Eq k => KeyedCollection [(k, v)] # | |
class Sequential col => Zippable col where #
Methods
zipWith :: (Sequential a, Sequential b) => (Element a -> Element b -> Element col) -> a -> b -> col #
zipWith generalises zip by zipping with the function given as the
first argument, instead of a tupling function. For example, zipWith (+)
zipWith3 :: (Sequential a, Sequential b, Sequential c) => (Element a -> Element b -> Element c -> Element col) -> a -> b -> c -> col #
Like zipWith, but works with 3 collections.
zipWith4 :: (Sequential a, Sequential b, Sequential c, Sequential d) => (Element a -> Element b -> Element c -> Element d -> Element col) -> a -> b -> c -> d -> col #
Like zipWith, but works with 4 collections.
zipWith5 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element col) -> a -> b -> c -> d -> e -> col #
Like zipWith, but works with 5 collections.
zipWith6 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element f -> Element col) -> a -> b -> c -> d -> e -> f -> col #
Like zipWith, but works with 6 collections.
zipWith7 :: (Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Sequential g) => (Element a -> Element b -> Element c -> Element d -> Element e -> Element f -> Element g -> Element col) -> a -> b -> c -> d -> e -> f -> g -> col #
Like zipWith, but works with 7 collections.
Collections that can be built chunk by chunk.
Use the Monad instance of Builder to chain append operations
and feed it into build:
>>>runST $ build 32 (append 'a' >> append 'b' >> append 'c') :: UArray Char"abc"
Associated Types
Mutable collection type used for incrementally writing chunks.
newtype Builder collection mutCollection step state err a :: * -> (* -> *) -> * -> (* -> *) -> * -> * -> * #
Constructors
| Builder | |
Fields
| |
Instances
| Monad state => Monad (Builder collection mutCollection step state err) | |
| Monad state => Functor (Builder collection mutCollection step state err) | |
| Monad state => Applicative (Builder collection mutCollection step state err) | |
| Monad state => MonadFailure (Builder collection mutCollection step state err) | |
| type Failure (Builder collection mutCollection step state err) | |
data BuildingState collection mutCollection step state :: * -> (* -> *) -> * -> * -> * #
The in-progress state of a building operation.
The previous buffers are in reverse order, and this contains the current buffer and the state of progress packing the elements inside.
Constructors
| BuildingState | |
Fields
| |