| Safe Haskell | None |
|---|
Data.Sequences
Description
Warning: This module should be considered highly experimental.
- class (Monoid seq, MonoTraversable seq, Integral (Index seq)) => IsSequence seq where
- type Index seq
- singleton :: Element seq -> seq
- fromList :: [Element seq] -> seq
- replicate :: Index seq -> Element seq -> seq
- replicateM :: Monad m => Index seq -> m (Element seq) -> m seq
- filter :: (Element seq -> Bool) -> seq -> seq
- filterM :: Monad m => (Element seq -> m Bool) -> seq -> m seq
- intersperse :: Element seq -> seq -> seq
- break :: (Element seq -> Bool) -> seq -> (seq, seq)
- span :: (Element seq -> Bool) -> seq -> (seq, seq)
- dropWhile :: (Element seq -> Bool) -> seq -> seq
- takeWhile :: (Element seq -> Bool) -> seq -> seq
- splitAt :: Index seq -> seq -> (seq, seq)
- take :: Index seq -> seq -> seq
- drop :: Index seq -> seq -> seq
- reverse :: seq -> seq
- find :: (Element seq -> Bool) -> seq -> Maybe (Element seq)
- partition :: (Element seq -> Bool) -> seq -> (seq, seq)
- sortBy :: (Element seq -> Element seq -> Ordering) -> seq -> seq
- cons :: Element seq -> seq -> seq
- uncons :: seq -> Maybe (Element seq, seq)
- groupBy :: (Element seq -> Element seq -> Bool) -> seq -> [seq]
- groupAllOn :: Eq b => (Element seq -> b) -> seq -> [seq]
- subsequences :: seq -> [seq]
- permutations :: seq -> [seq]
- class (IsSequence seq, Eq (Element seq)) => EqSequence seq where
- stripPrefix :: seq -> seq -> Maybe seq
- isPrefixOf :: seq -> seq -> Bool
- stripSuffix :: seq -> seq -> Maybe seq
- isSuffixOf :: seq -> seq -> Bool
- isInfixOf :: seq -> seq -> Bool
- group :: seq -> [seq]
- groupAll :: seq -> [seq]
- elem :: Element seq -> seq -> Bool
- notElem :: Element seq -> seq -> Bool
- class (EqSequence seq, Ord (Element seq)) => OrdSequence seq where
- sort :: seq -> seq
- class (IsSequence l, IsSequence s) => LazySequence l s | l -> s, s -> l where
- toChunks :: l -> [s]
- fromChunks :: [s] -> l
- toStrict :: l -> s
- fromStrict :: s -> l
- class (IsSequence t, IsSequence b) => Textual t b | t -> b, b -> t where
- words :: t -> [t]
- unwords :: [t] -> t
- lines :: t -> [t]
- unlines :: [t] -> t
- encodeUtf8 :: t -> b
- decodeUtf8 :: b -> t
- toLower :: t -> t
- toUpper :: t -> t
- toCaseFold :: t -> t
- class LooseMap t where
- type LooseMapConstraint t e :: Constraint
- looseMap :: (LooseMapConstraint t e1, LooseMapConstraint t e2) => (e1 -> e2) -> t e1 -> t e2
Documentation
class (Monoid seq, MonoTraversable seq, Integral (Index seq)) => IsSequence seq whereSource
Laws:
fromList . toList = id fromList (x <> y) = fromList x <> fromList y otoList (fromList x <> fromList y) = x <> y
Methods
singleton :: Element seq -> seqSource
fromList :: [Element seq] -> seqSource
replicate :: Index seq -> Element seq -> seqSource
replicateM :: Monad m => Index seq -> m (Element seq) -> m seqSource
filter :: (Element seq -> Bool) -> seq -> seqSource
filterM :: Monad m => (Element seq -> m Bool) -> seq -> m seqSource
intersperse :: Element seq -> seq -> seqSource
break :: (Element seq -> Bool) -> seq -> (seq, seq)Source
span :: (Element seq -> Bool) -> seq -> (seq, seq)Source
dropWhile :: (Element seq -> Bool) -> seq -> seqSource
takeWhile :: (Element seq -> Bool) -> seq -> seqSource
splitAt :: Index seq -> seq -> (seq, seq)Source
take :: Index seq -> seq -> seqSource
drop :: Index seq -> seq -> seqSource
find :: (Element seq -> Bool) -> seq -> Maybe (Element seq)Source
partition :: (Element seq -> Bool) -> seq -> (seq, seq)Source
sortBy :: (Element seq -> Element seq -> Ordering) -> seq -> seqSource
cons :: Element seq -> seq -> seqSource
uncons :: seq -> Maybe (Element seq, seq)Source
groupBy :: (Element seq -> Element seq -> Bool) -> seq -> [seq]Source
groupAllOn :: Eq b => (Element seq -> b) -> seq -> [seq]Source
Similar to standard groupBy, but operates on the whole collection,
not just the consecutive items.
subsequences :: seq -> [seq]Source
permutations :: seq -> [seq]Source
Instances
| IsSequence ByteString | |
| IsSequence ByteString | |
| IsSequence Text | |
| IsSequence Text | |
| IsSequence [a] | |
| IsSequence (Seq a) | |
| IsSequence (Vector a) | |
| Unbox a => IsSequence (Vector a) | |
| Storable a => IsSequence (Vector a) |
class (IsSequence seq, Eq (Element seq)) => EqSequence seq whereSource
Methods
stripPrefix :: seq -> seq -> Maybe seqSource
isPrefixOf :: seq -> seq -> BoolSource
stripSuffix :: seq -> seq -> Maybe seqSource
isSuffixOf :: seq -> seq -> BoolSource
isInfixOf :: seq -> seq -> BoolSource
groupAll :: seq -> [seq]Source
Similar to standard group, but operates on the whole collection,
not just the consecutive items.
Instances
| EqSequence ByteString | |
| EqSequence ByteString | |
| EqSequence Text | |
| EqSequence Text | |
| Eq a => EqSequence [a] | |
| Eq a => EqSequence (Seq a) | |
| Eq a => EqSequence (Vector a) | |
| (Eq a, Unbox a) => EqSequence (Vector a) | |
| (Eq a, Storable a) => EqSequence (Vector a) |
class (EqSequence seq, Ord (Element seq)) => OrdSequence seq whereSource
Instances
| OrdSequence ByteString | |
| OrdSequence ByteString | |
| OrdSequence Text | |
| OrdSequence Text | |
| Ord a => OrdSequence [a] | |
| Ord a => OrdSequence (Seq a) | |
| Ord a => OrdSequence (Vector a) | |
| (Ord a, Unbox a) => OrdSequence (Vector a) | |
| (Ord a, Storable a) => OrdSequence (Vector a) |
class (IsSequence l, IsSequence s) => LazySequence l s | l -> s, s -> l whereSource
Instances
class (IsSequence t, IsSequence b) => Textual t b | t -> b, b -> t whereSource
Instances
| Textual Text ByteString | |
| Textual Text ByteString | |
| (~ * c Char, ~ * w Word8) => Textual [c] [w] |
A map-like function which doesn't obey the Functor laws,
and/or requires extra constraints on the contained values.
Associated Types
type LooseMapConstraint t e :: ConstraintSource
Methods
looseMap :: (LooseMapConstraint t e1, LooseMapConstraint t e2) => (e1 -> e2) -> t e1 -> t e2Source