| 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 :: !(CountOf step)
- curChunk :: mutCollection state
- chunkSize :: !(CountOf step)
- class Copy a where
Documentation
class Zippable col => BoxedZippable col where Source #
Methods
zip :: (Sequential a, Sequential b, Element col ~ (Element a, Element b)) => a -> b -> col Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
Like zip, but works with 7 collections.
unzip :: (Sequential a, Sequential b, Element col ~ (Element a, Element b)) => col -> (a, b) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
Like unzip, but works on a collection of 7-element tuples.
Instances
| BoxedZippable [a] Source # | |
| BoxedZippable (Array ty) Source # | |
type family Element container Source #
Element type of a collection
Instances
| type Element String Source # | |
| type Element AsciiString Source # | |
| type Element Bitmap Source # | |
| type Element [a] Source # | |
| type Element (Block ty) Source # | |
| type Element (UArray ty) Source # | |
| type Element (Array ty) Source # | |
| type Element (NonEmpty a) Source # | |
| type Element (ChunkedUArray ty) Source # | |
| type Element (DList a) Source # | |
class InnerFunctor c where Source #
A monomorphic functor that maps the inner values to values of the same type
Methods
imap :: (Element c -> Element c) -> c -> c Source #
imap :: (Functor f, Element (f a) ~ a, f a ~ c) => (Element c -> Element c) -> c -> c Source #
Instances
| InnerFunctor String Source # | |
| InnerFunctor AsciiString Source # | |
| InnerFunctor Bitmap Source # | |
| InnerFunctor [a] Source # | |
| PrimType ty => InnerFunctor (UArray ty) Source # | |
| InnerFunctor (Array ty) Source # | |
class Foldable collection where Source #
Give the ability to fold a collection on itself
Methods
foldl :: (a -> Element collection -> a) -> a -> collection -> a Source #
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 Source #
Left-associative fold of a structure but with strict application of the operator.
foldr :: (Element collection -> a -> a) -> a -> collection -> a Source #
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 Source #
Right-associative fold of a structure, but with strict application of the operator.
class Functor collection => Mappable collection where Source #
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) Source #
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) Source #
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) Source #
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) Source #
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 () Source #
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 () Source #
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.
class (IsList c, Item c ~ Element c) => Collection c where Source #
A set of methods for ordered colection
Methods
Check if a collection is empty
length :: c -> CountOf (Element c) Source #
Length of a collection (number of Element c)
elem :: forall a. (Eq a, a ~ Element c) => Element c -> c -> Bool Source #
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 Source #
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 Source #
Get the maximum element of a collection
minimum :: forall a. (Ord a, a ~ Element c) => NonEmpty c -> Element c Source #
Get the minimum element of a collection
any :: (Element c -> Bool) -> c -> Bool Source #
Determine is any elements of the collection satisfy the predicate
all :: (Element c -> Bool) -> c -> Bool Source #
Determine is all elements of the collection satisfy the predicate
Instances
| Collection String Source # | |
| Collection AsciiString Source # | |
| Collection Bitmap Source # | |
| Collection [a] Source # | |
| PrimType ty => Collection (Block ty) Source # | |
| PrimType ty => Collection (UArray ty) Source # | |
| Collection (Array ty) Source # | |
| Collection c => Collection (NonEmpty c) Source # | |
| PrimType ty => Collection (ChunkedUArray ty) Source # | |
| Collection (DList a) Source # | |
NonEmpty property for any Collection
This can only be made, through the nonEmpty smart contructor
getNonEmpty :: NonEmpty a -> a Source #
nonEmpty :: Collection c => c -> Maybe (NonEmpty c) Source #
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 Source #
same as nonEmpty, but assume that the collection is non empty,
and return an asynchronous error if it is.
class (IsList c, Item c ~ Element c, Monoid c, Collection c) => Sequential c where Source #
A set of methods for ordered colection
Methods
take :: CountOf (Element c) -> c -> c Source #
Take the first @n elements of a collection
revTake :: CountOf (Element c) -> c -> c Source #
Take the last @n elements of a collection
drop :: CountOf (Element c) -> c -> c Source #
Drop the first @n elements of a collection
revDrop :: CountOf (Element c) -> c -> c Source #
Drop the last @n elements of a collection
splitAt :: CountOf (Element c) -> c -> (c, c) Source #
Split the collection at the @n'th elements
revSplitAt :: CountOf (Element c) -> c -> (c, c) Source #
Split the collection at the @n'th elements from the end
splitOn :: (Element c -> Bool) -> c -> [c] Source #
Split on a specific elements returning a list of colletion
break :: (Element c -> Bool) -> c -> (c, c) Source #
Split a collection when the predicate return true
breakElem :: Eq (Element c) => Element c -> c -> (c, c) Source #
Split a collection when the predicate return true
intersperse :: Element c -> c -> c Source #
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 Source #
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) Source #
Split a collection while the predicate return true
filter :: (Element c -> Bool) -> c -> c Source #
Filter all the elements that satisfy the predicate
partition :: (Element c -> Bool) -> c -> (c, c) Source #
Partition the elements thtat satisfy the predicate and those that don't
Reverse a collection
uncons :: c -> Maybe (Element c, c) Source #
Decompose a collection into its first element and the remaining collection. If the collection is empty, returns Nothing.
unsnoc :: c -> Maybe (c, Element c) Source #
Decompose a collection into a collection without its last element, and the last element If the collection is empty, returns Nothing.
snoc :: c -> Element c -> c Source #
Prepend an element to an ordered collection
cons :: Element c -> c -> c Source #
Append an element to an ordered collection
find :: (Element c -> Bool) -> c -> Maybe (Element c) Source #
Find an element in an ordered collection
sortBy :: (Element c -> Element c -> Ordering) -> c -> c Source #
Sort an ordered collection using the specified order function
singleton :: Element c -> c Source #
Create a collection with a single element
head :: NonEmpty c -> Element c Source #
get the first element of a non-empty collection
last :: NonEmpty c -> Element c Source #
get the last element of a non-empty collection
tail :: NonEmpty c -> c Source #
Extract the elements after the first element of a non-empty collection.
init :: NonEmpty c -> c Source #
Extract the elements before the last element of a non-empty collection.
replicate :: CountOf (Element c) -> Element c -> c Source #
Create a collection where the element in parameter is repeated N time
isPrefixOf :: Eq (Element c) => c -> c -> Bool Source #
Takes two collections and returns True iff the first collection is a prefix of the second.
isPrefixOf :: Eq c => c -> c -> Bool Source #
Takes two collections and returns True iff the first collection is a prefix of the second.
isSuffixOf :: Eq (Element c) => c -> c -> Bool Source #
Takes two collections and returns True iff the first collection is a suffix of the second.
isSuffixOf :: Eq c => c -> c -> Bool Source #
Takes two collections and returns True iff the first collection is a suffix of the second.
isInfixOf :: Eq (Element c) => c -> c -> Bool Source #
Takes two collections and returns True iff the first collection is an infix of the second.
isInfixOf :: Eq c => c -> c -> Bool Source #
Takes two collections and returns True iff the first collection is an infix of the second.
Instances
| Sequential String Source # | |
| Sequential AsciiString Source # | |
| Sequential Bitmap Source # | |
| Sequential [a] Source # | |
| PrimType ty => Sequential (Block ty) Source # | |
| PrimType ty => Sequential (UArray ty) Source # | |
| Sequential (Array ty) Source # | |
| PrimType ty => Sequential (ChunkedUArray ty) Source # | |
| Sequential (DList a) Source # | |
class MutableCollection c where Source #
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
Associated Types
type MutableFreezed c Source #
type MutableKey c Source #
type MutableValue c Source #
Methods
unsafeThaw :: PrimMonad prim => MutableFreezed c -> prim (c (PrimState prim)) Source #
unsafeFreeze :: PrimMonad prim => c (PrimState prim) -> prim (MutableFreezed c) Source #
thaw :: PrimMonad prim => MutableFreezed c -> prim (c (PrimState prim)) Source #
freeze :: PrimMonad prim => c (PrimState prim) -> prim (MutableFreezed c) Source #
mutNew :: PrimMonad prim => CountOf (MutableValue c) -> prim (c (PrimState prim)) Source #
mutUnsafeWrite :: PrimMonad prim => c (PrimState prim) -> MutableKey c -> MutableValue c -> prim () Source #
mutWrite :: PrimMonad prim => c (PrimState prim) -> MutableKey c -> MutableValue c -> prim () Source #
mutUnsafeRead :: PrimMonad prim => c (PrimState prim) -> MutableKey c -> prim (MutableValue c) Source #
mutRead :: PrimMonad prim => c (PrimState prim) -> MutableKey c -> prim (MutableValue c) Source #
Instances
| MutableCollection MutableBitmap Source # | |
| PrimType ty => MutableCollection (MutableBlock ty) Source # | |
| PrimType ty => MutableCollection (MUArray ty) Source # | |
| MutableCollection (MArray ty) Source # | |
class IndexedCollection c where Source #
Collection of elements that can indexed by int
Methods
(!) :: c -> Offset (Element c) -> Maybe (Element c) Source #
findIndex :: (Element c -> Bool) -> c -> Maybe (Offset (Element c)) Source #
Instances
| IndexedCollection String Source # | |
| IndexedCollection Bitmap Source # | |
| IndexedCollection [a] Source # | |
| PrimType ty => IndexedCollection (Block ty) Source # | |
| PrimType ty => IndexedCollection (UArray ty) Source # | |
| IndexedCollection (Array ty) Source # | |
| PrimType ty => IndexedCollection (ChunkedUArray ty) Source # | |
class KeyedCollection c where Source #
Collection of things that can be looked up by Key
Minimal complete definition
Instances
| Eq k => KeyedCollection [(k, v)] Source # | |
class Sequential col => Zippable col where Source #
Methods
zipWith :: (Sequential a, Sequential b) => (Element a -> Element b -> Element col) -> a -> b -> col Source #
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 Source #
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 Source #
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 Source #
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 Source #
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 Source #
Like zipWith, but works with 7 collections.
class Buildable col where Source #
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
type Mutable col :: * -> * Source #
Mutable collection type used for incrementally writing chunks.
newtype Builder collection mutCollection step state a Source #
Constructors
| Builder | |
Fields
| |
data BuildingState collection mutCollection step state Source #
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
| |