Data.Sequences

Warning: This module should be considered highly experimental.

Documentation

class (Integral (Index seq), GrowingAppend seq) => SemiSequence seq where

SemiSequence was created to share code between IsSequence and MinLen.

Semi means SemiGroup A SemiSequence can accomodate a SemiGroup such as NonEmpty or MinLen A Monoid should be able to fill out IsSequence.

SemiSequence operations maintain the same type because they all maintain the same number of elements or increase them. However, a decreasing function such as filter may change they type. For example, from NonEmpty to '[]' This type-changing function exists on NonNull as nfilter

filter and other such functions are placed in IsSequence

Associated Types

type Index seq

Methods

intersperse :: Element seq -> seq -> seq

reverse :: seq -> seq

find :: (Element seq -> Bool) -> seq -> Maybe (Element seq)

sortBy :: (Element seq -> Element seq -> Ordering) -> seq -> seq

cons :: Element seq -> seq -> seq

snoc :: seq -> Element seq -> seq

Instances

SemiSequence ByteString

SemiSequence ByteString

SemiSequence Text

SemiSequence Text

SemiSequence [a]

SemiSequence (Seq a)

Storable a => SemiSequence (Vector a)

SemiSequence (NonEmpty a)

SemiSequence (Vector a)

Unbox a => SemiSequence (Vector a)

SemiSequence (DList a)

SemiSequence seq => SemiSequence (MinLen nat seq)

singleton :: IsSequence seq => Element seq -> seq

class (Monoid seq, MonoTraversable seq, SemiSequence seq, MonoPointed seq) => IsSequence seq where

Sequence Laws:

fromList . otoList = id
fromList (x <> y) = fromList x <> fromList y
otoList (fromList x <> fromList y) = x <> y

Minimal complete definition

Nothing

Methods

fromList :: [Element 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)

unsafeSplitAt :: Index seq -> seq -> (seq, seq)

take :: Index seq -> seq -> seq

unsafeTake :: Index seq -> seq -> seq

drop :: Index seq -> seq -> seq

unsafeDrop :: Index seq -> seq -> seq

partition :: (Element seq -> Bool) -> seq -> (seq, seq)

uncons :: seq -> Maybe (Element seq, seq)

unsnoc :: seq -> Maybe (seq, Element seq)

filter :: (Element seq -> Bool) -> seq -> seq

filterM :: Monad m => (Element seq -> m Bool) -> seq -> m seq

replicate :: Index seq -> Element seq -> seq

replicateM :: Monad m => Index seq -> m (Element seq) -> m seq

groupBy :: (Element seq -> Element seq -> Bool) -> seq -> [seq]

groupAllOn :: Eq b => (Element seq -> b) -> seq -> [seq]

Similar to standard groupBy, but operates on the whole collection, not just the consecutive items.

subsequences :: seq -> [seq]

permutations :: seq -> [seq]

tailEx :: seq -> seq

initEx :: seq -> seq

unsafeTail :: seq -> seq

unsafeInit :: seq -> seq

index :: seq -> Index seq -> Maybe (Element seq)

indexEx :: seq -> Index seq -> Element seq

unsafeIndex :: seq -> Index seq -> Element seq

Instances

IsSequence ByteString

IsSequence ByteString

IsSequence Text

IsSequence Text

IsSequence [a]

IsSequence (Seq a)

Storable a => IsSequence (Vector a)

IsSequence (Vector a)

Unbox a => IsSequence (Vector a)

IsSequence (DList a)

defaultFind :: MonoFoldable seq => (Element seq -> Bool) -> seq -> Maybe (Element seq)

defaultIntersperse :: IsSequence seq => Element seq -> seq -> seq

defaultReverse :: IsSequence seq => seq -> seq

defaultSortBy :: IsSequence seq => (Element seq -> Element seq -> Ordering) -> seq -> seq

vectorSortBy :: Vector v e => (e -> e -> Ordering) -> v e -> v e

vectorSort :: (Vector v e, Ord e) => v e -> v e

defaultCons :: IsSequence seq => Element seq -> seq -> seq

defaultSnoc :: IsSequence seq => seq -> Element seq -> seq

tailDef :: IsSequence seq => seq -> seq

like Data.List.tail, but an input of mempty returns mempty

initDef :: IsSequence seq => seq -> seq

like Data.List.init, but an input of mempty returns mempty

class (MonoFoldableEq seq, IsSequence seq, Eq (Element seq)) => EqSequence seq where

Minimal complete definition

Nothing

Methods

stripPrefix :: seq -> seq -> Maybe seq

stripSuffix :: seq -> seq -> Maybe seq

isPrefixOf :: seq -> seq -> Bool

isSuffixOf :: seq -> seq -> Bool

isInfixOf :: seq -> seq -> Bool

group :: seq -> [seq]

groupAll :: seq -> [seq]

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, Storable a) => EqSequence (Vector a)

Eq a => EqSequence (Vector a)

(Eq a, Unbox a) => EqSequence (Vector a)

elem :: EqSequence seq => Element seq -> seq -> Bool

Deprecated: use oelem

notElem :: EqSequence seq => Element seq -> seq -> Bool

Deprecated: use onotElem

class (EqSequence seq, MonoFoldableOrd seq) => OrdSequence seq where

Minimal complete definition

Nothing

Methods

sort :: seq -> seq

Instances

OrdSequence ByteString

OrdSequence ByteString

OrdSequence Text

OrdSequence Text

Ord a => OrdSequence [a]

Ord a => OrdSequence (Seq a)

(Ord a, Storable a) => OrdSequence (Vector a)

Ord a => OrdSequence (Vector a)

(Ord a, Unbox a) => OrdSequence (Vector a)

class (IsSequence t, IsString t, Element t ~ Char) => Textual t where

Minimal complete definition

words, unwords, lines, unlines, toLower, toUpper, toCaseFold

Methods

words :: t -> [t]

unwords :: [t] -> t

lines :: t -> [t]

unlines :: [t] -> t

toLower :: t -> t

toUpper :: t -> t

toCaseFold :: t -> t

breakWord :: t -> (t, t)

breakLine :: t -> (t, t)

Instances

Textual Text

Textual Text

(~) * c Char => Textual [c]

catMaybes :: (IsSequence (f (Maybe t)), Functor f, Element (f (Maybe t)) ~ Maybe t) => f (Maybe t) -> f t

Takes all of the Just values from a sequence of Maybe ts and concatenates them into an unboxed sequence of ts.

Since 0.6.2

sortOn :: (Ord o, SemiSequence seq) => (Element seq -> o) -> seq -> seq

Same as sortBy . comparing.

Sicne 0.7.0