| 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 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
- 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
- newtype Builder collection mutCollection step state a = Builder {
- runBuilder :: State (Offset step, BuildingState collection mutCollection step (PrimState state)) state a
- data BuildingState collection mutCollection step state = BuildingState {
- prevChunks :: [collection]
- prevChunksSize :: !(Size step)
- curChunk :: mutCollection state
- chunkSize :: !(Size 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 AsciiString # | |
| InnerFunctor Bitmap # | |
| InnerFunctor [a] # | |
| PrimType ty => InnerFunctor (UArray ty) # | |
| InnerFunctor (Array 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.
Also note that if you want an efficient left-fold, you probably want to use foldl' instead of foldl. The reason for this is that latter does not force the "inner" results (e.g. z f x1 in the above example) before applying them to the operator (e.g. to (f x2)). This results in a thunk chain O(n) elements long, which then must be evaluated from the outside-in.
foldl' :: (a -> Element collection -> a) -> a -> collection -> a #
Left-associative fold of a structure but 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 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 () #
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 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] # | |
| PrimType ty => Collection (UArray ty) # | |
| Collection (Array ty) # | |
| Collection c => Collection (NonEmpty c) # | |
| PrimType ty => Collection (ChunkedUArray ty) # | |
NonEmpty property for any Collection
This can only be made, through the nonEmpty smart contructor
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 the first @n elements of a collection
Take the last @n elements of a collection
Drop the first @n elements of a collection
Drop the last @n elements of a collection
splitAt :: Int -> c -> (c, c) #
Split the collection at the @n'th elements
revSplitAt :: Int -> 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
breakElem :: Eq (Element c) => Element c -> c -> (c, c) #
Split a collection when the predicate return true
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
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.
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.
Instances
| Sequential String # | |
| Sequential AsciiString # | |
| Sequential Bitmap # | |
| Sequential [a] # | |
| PrimType ty => Sequential (UArray ty) # | |
| Sequential (Array ty) # | |
| 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 => Int -> 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 # | |
| PrimType ty => MutableCollection (MUArray ty) # | |
| MutableCollection (MArray ty) # | |
class IndexedCollection c where #
Collection of elements that can indexed by int
Instances
| IndexedCollection String # | |
| IndexedCollection Bitmap # | |
| IndexedCollection [a] # | |
| PrimType ty => IndexedCollection (UArray ty) # | |
| IndexedCollection (Array 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 a #
Constructors
| Builder | |
Fields
| |
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
| |