| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Data.Sequences
Description
Abstractions over sequential data structures, like lists and vectors.
Synopsis
- class ( Integral ( Index seq), GrowingAppend seq) => SemiSequence seq where
- singleton :: MonoPointed seq => Element seq -> seq
-
class
(
Monoid
seq,
MonoTraversable
seq,
SemiSequence
seq,
MonoPointed
seq) =>
IsSequence
seq
where
- fromList :: [ Element seq] -> seq
- lengthIndex :: seq -> Index 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
- dropEnd :: 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]
- subsequences :: seq -> [seq]
- permutations :: seq -> [seq]
- tailEx :: seq -> seq
- tailMay :: seq -> Maybe seq
- initEx :: seq -> seq
- initMay :: IsSequence seq => seq -> Maybe 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
- splitWhen :: ( Element seq -> Bool ) -> seq -> [seq]
- 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
- defaultSplitWhen :: IsSequence seq => ( Element seq -> Bool ) -> 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
- initDef :: IsSequence seq => seq -> seq
- splitElem :: ( IsSequence seq, Eq ( Element seq)) => Element seq -> seq -> [seq]
- splitSeq :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> [seq]
- replaceSeq :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> seq -> seq
- stripPrefix :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> Maybe seq
- stripSuffix :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> Maybe seq
- dropPrefix :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> seq
- dropSuffix :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> seq
- ensurePrefix :: ( Eq ( Element seq), IsSequence seq) => seq -> seq -> seq
- ensureSuffix :: ( Eq ( Element seq), IsSequence seq) => seq -> seq -> seq
- isPrefixOf :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> Bool
- isSuffixOf :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> Bool
- isInfixOf :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> Bool
- group :: ( IsSequence seq, Eq ( Element seq)) => seq -> [seq]
- groupAll :: ( IsSequence seq, Eq ( Element seq)) => seq -> [seq]
- delete :: ( IsSequence seq, Eq ( Element seq)) => Element seq -> seq -> seq
- deleteBy :: ( IsSequence seq, Eq ( Element seq)) => ( Element seq -> Element seq -> Bool ) -> Element seq -> seq -> seq
- splitElemStrictBS :: Word8 -> ByteString -> [ ByteString ]
- stripPrefixStrictBS :: ByteString -> ByteString -> Maybe ByteString
- stripSuffixStrictBS :: ByteString -> ByteString -> Maybe ByteString
- splitSeqLazyBS :: Word8 -> ByteString -> [ ByteString ]
- stripPrefixLazyBS :: ByteString -> ByteString -> Maybe ByteString
- stripSuffixLazyBS :: ByteString -> ByteString -> Maybe ByteString
- splitSeqStrictText :: Text -> Text -> [ Text ]
- replaceSeqStrictText :: Text -> Text -> Text -> Text
- splitSeqLazyText :: Text -> Text -> [ Text ]
- replaceSeqLazyText :: Text -> Text -> Text -> Text
- sort :: ( SemiSequence seq, Ord ( Element seq)) => seq -> seq
-
class
(
IsSequence
t,
IsString
t,
Element
t ~
Char
) =>
Textual
t
where
- words :: t -> [t]
- unwords :: ( Element seq ~ t, MonoFoldable seq) => seq -> t
- lines :: t -> [t]
- unlines :: ( Element seq ~ t, MonoFoldable seq) => seq -> t
- toLower :: t -> t
- toUpper :: t -> t
- toCaseFold :: t -> t
- breakWord :: t -> (t, t)
- breakLine :: t -> (t, t)
- catMaybes :: ( IsSequence (f ( Maybe t)), Functor f, Element (f ( Maybe t)) ~ Maybe t) => f ( Maybe t) -> f t
- sortOn :: ( Ord o, SemiSequence seq) => ( Element seq -> o) -> seq -> seq
-
class
(
IsSequence
lazy,
IsSequence
strict) =>
LazySequence
lazy strict | lazy -> strict, strict -> lazy
where
- toChunks :: lazy -> [strict]
- fromChunks :: [strict] -> lazy
- toStrict :: lazy -> strict
- fromStrict :: strict -> lazy
- pack :: IsSequence seq => [ Element seq] -> seq
- unpack :: MonoFoldable mono => mono -> [ Element mono]
- repack :: ( MonoFoldable a, IsSequence b, Element a ~ Element b) => a -> b
-
class
(
Textual
textual,
IsSequence
binary) =>
Utf8
textual binary | textual -> binary, binary -> textual
where
- encodeUtf8 :: textual -> binary
- decodeUtf8 :: binary -> textual
Documentation
class ( Integral ( Index seq), GrowingAppend seq) => SemiSequence seq where Source #
SemiSequence
was created to share code between
IsSequence
and
NonNull
.
Semi
means
SemiGroup
A
SemiSequence
can accomodate a
SemiGroup
such as
NonEmpty
or
NonNull
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
NOTE
: Like
GrowingAppend
, ideally we'd have a
Semigroup
superclass
constraint here, but that would pull in more dependencies to this package
than desired.
Methods
intersperse :: Element seq -> seq -> seq Source #
intersperse
takes an element and intersperses that element between
the elements of the sequence.
> intersperse ',' "abcde"
"a,b,c,d,e"
reverse :: seq -> seq Source #
Reverse a sequence
> reverse "hello world"
"dlrow olleh"
find :: ( Element seq -> Bool ) -> seq -> Maybe ( Element seq) Source #
find
takes a predicate and a sequence and returns the first element in
the sequence matching the predicate, or
Nothing
if there isn't an element
that matches the predicate.
>find(== 5) [1 .. 10]Just5 >find(== 15) [1 .. 10]Nothing
sortBy :: ( Element seq -> Element seq -> Ordering ) -> seq -> seq Source #
Sort a sequence using an supplied element ordering function.
> let compare' x y = casecomparex y of LT -> GT; EQ -> EQ; GT -> LT >sortBycompare' [5,3,6,1,2,4] [6,5,4,3,2,1]
cons :: Element seq -> seq -> seq Source #
Prepend an element onto a sequence.
> 4 `cons` [1,2,3]
[4,1,2,3]
snoc :: seq -> Element seq -> seq Source #
Append an element onto a sequence.
> [1,2,3] `snoc` 4
[1,2,3,4]
Instances
singleton :: MonoPointed seq => Element seq -> seq Source #
class ( Monoid seq, MonoTraversable seq, SemiSequence seq, MonoPointed seq) => IsSequence seq where Source #
Sequence Laws:
fromList.otoList=idfromList(x <> y) =fromListx <>fromListyotoList(fromListx <>fromListy) = x <> y
Minimal complete definition
Nothing
Methods
fromList :: [ Element seq] -> seq Source #
Convert a list to a sequence.
>fromList[a,b,c] :: Text "abc"
lengthIndex :: seq -> Index seq Source #
lengthIndex
returns the length of a sequence as
.
Index
seq
Since: 1.0.2
break :: ( Element seq -> Bool ) -> seq -> (seq, seq) Source #
break
applies a predicate to a sequence, and returns a tuple where
the first element is the longest prefix (possibly empty) of elements that
do not satisfy
the predicate. The second element of the tuple is the
remainder of the sequence.
is equivalent to
break
p
span
(
not
. p)
>break(> 3) (fromList[1,2,3,4,1,2,3,4] ::VectorInt) (fromList [1,2,3],fromList [4,1,2,3,4]) >break(<z) (fromList"abc" ::Text) ("","abc") >break(>z) (fromList"abc" ::Text) ("abc","")
span :: ( Element seq -> Bool ) -> seq -> (seq, seq) Source #
span
applies a predicate to a sequence, and returns a tuple where
the first element is the longest prefix (possibly empty) that
does satisfy
the predicate. The second element of the tuple is the
remainder of the sequence.
is equivalent to
span
p xs
(
takeWhile
p xs,
dropWhile
p xs)
>span(< 3) (fromList[1,2,3,4,1,2,3,4] ::VectorInt) (fromList [1,2],fromList [3,4,1,2,3,4]) >span(<z) (fromList"abc" ::Text) ("abc","") >span(< 0) 1,2,3
dropWhile :: ( Element seq -> Bool ) -> seq -> seq Source #
dropWhile
returns the suffix remaining after
takeWhile
.
>dropWhile(< 3) [1,2,3,4,5,1,2,3] [3,4,5,1,2,3] >dropWhile(<z) (fromList"abc" ::Text) ""
takeWhile :: ( Element seq -> Bool ) -> seq -> seq Source #
takeWhile
applies a predicate to a sequence, and returns the
longest prefix (possibly empty) of the sequence of elements that
satisfy
the predicate.
>takeWhile(< 3) [1,2,3,4,5,1,2,3] [1,2] >takeWhile(<z) (fromList"abc" ::Text) "abc"
splitAt :: Index seq -> seq -> (seq, seq) Source #
returns a tuple where the first element is the prefix of
the sequence
splitAt
n se
se
with length
n
, and the second element is the remainder of
the sequence.
>splitAt6 "Hello world!" ("Hello ","world!") >splitAt3 (fromList[1,2,3,4,5] ::VectorInt) (fromList [1,2,3],fromList [4,5])
unsafeSplitAt :: Index seq -> seq -> (seq, seq) Source #
Equivalent to
splitAt
.
take :: Index seq -> seq -> seq Source #
returns the prefix of a sequence of length
take
n
n
, or the
sequence itself if
n >
.
olength
seq
>take3 "abcdefg" "abc" >take4 (fromList[1,2,3,4,5,6] ::VectorInt) fromList [1,2,3,4]
unsafeTake :: Index seq -> seq -> seq Source #
Equivalent to
take
.
drop :: Index seq -> seq -> seq Source #
returns the suffix of a sequence after the first
drop
n
n
elements, or an empty sequence if
n >
.
olength
seq
>drop3 "abcdefg" "defg" >drop4 (fromList[1,2,3,4,5,6] ::VectorInt) fromList [5,6]
unsafeDrop :: Index seq -> seq -> seq Source #
Equivalent to
drop
dropEnd :: Index seq -> seq -> seq Source #
Same as
drop
but drops from the end of the sequence instead.
>dropEnd3 "abcdefg" "abcd" >dropEnd4 (fromList[1,2,3,4,5,6] ::VectorInt) fromList [1,2]
Since: 1.0.4.0
partition :: ( Element seq -> Bool ) -> seq -> (seq, seq) Source #
partition
takes a predicate and a sequence and returns the pair of
sequences of elements which do and do not satisfy the predicate.
partitionp se = (filterp se,filter(not. p) se)
uncons :: seq -> Maybe ( Element seq, seq) Source #
uncons
returns the tuple of the first element of a sequence and the rest
of the sequence, or
Nothing
if the sequence is empty.
>uncons(fromList[1,2,3,4] ::VectorInt)Just(1,fromList [2,3,4]) >uncons([] :: [Int])Nothing
unsnoc :: seq -> Maybe (seq, Element seq) Source #
unsnoc
returns the tuple of the init of a sequence and the last element,
or
Nothing
if the sequence is empty.
>unsnoc(fromList[1,2,3,4] ::VectorInt)Just(fromList [1,2,3],4) >unsnoc([] :: [Int])Nothing
filter :: ( Element seq -> Bool ) -> seq -> seq Source #
filter
given a predicate returns a sequence of all elements that satisfy
the predicate.
> filter (< 5) [1 .. 10]
[1,2,3,4]
filterM :: Monad m => ( Element seq -> m Bool ) -> seq -> m seq Source #
The monadic version of
filter
.
replicate :: Index seq -> Element seq -> seq Source #
is a sequence of length
replicate
n x
n
with
x
as the
value of every element.
>replicate10a:: Text "aaaaaaaaaa"
replicateM :: Monad m => Index seq -> m ( Element seq) -> m seq Source #
The monadic version of
replicateM
.
groupBy :: ( Element seq -> Element seq -> Bool ) -> seq -> [seq] Source #
group
takes a sequence and returns a list of sequences such that the
concatenation of the result is equal to the argument. Each subsequence in
the result contains only equal elements, using the supplied equality test.
> groupBy (==) Mississippi
[M,"i","ss","i","ss","i","pp","i"]
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 #
subsequences
returns a list of all subsequences of the argument.
> subsequences "abc"
["","a","b","ab","c","ac","bc","abc"]
permutations :: seq -> [seq] Source #
permutations
returns a list of all permutations of the argument.
> permutations "abc"
["abc","bac","cba","bca","cab","acb"]
Unsafe
Get the tail of a sequence, throw an exception if the sequence is empty.
> tailEx [1,2,3]
[2,3]
tailMay :: seq -> Maybe seq Source #
Safe version of
tailEx
.
Returns
Nothing
instead of throwing an exception when encountering
an empty monomorphic container.
Since: 1.0.0
Unsafe
Get the init of a sequence, throw an exception if the sequence is empty.
> initEx [1,2,3]
[1,2]
initMay :: IsSequence seq => seq -> Maybe seq Source #
Safe version of
initEx
.
Returns
Nothing
instead of throwing an exception when encountering
an empty monomorphic container.
Since: 1.0.0
unsafeTail :: seq -> seq Source #
Equivalent to
tailEx
.
unsafeInit :: seq -> seq Source #
Equivalent to
initEx
.
index :: seq -> Index seq -> Maybe ( Element seq) Source #
Get the element of a sequence at a certain index, returns
Nothing
if that index does not exist.
>index(fromList[1,2,3] ::VectorInt) 1Just2 >index(fromList[1,2,3] ::VectorInt) 4Nothing
indexEx :: seq -> Index seq -> Element seq Source #
Unsafe
Get the element of a sequence at a certain index, throws an exception if the index does not exist.
unsafeIndex :: seq -> Index seq -> Element seq Source #
Equivalent to
indexEx
.
splitWhen :: ( Element seq -> Bool ) -> seq -> [seq] Source #
splitWhen
splits a sequence into components delimited by separators,
where the predicate returns True for a separator element. The resulting
components do not contain the separators. Two adjacent separators result
in an empty component in the output. The number of resulting components
is greater by one than number of separators.
Since 0.9.3
Instances
defaultFind :: MonoFoldable seq => ( Element seq -> Bool ) -> seq -> Maybe ( Element seq) Source #
defaultIntersperse :: IsSequence seq => Element seq -> seq -> seq Source #
Use
Data.List
's implementation of
intersperse
.
defaultReverse :: IsSequence seq => seq -> seq Source #
defaultSortBy :: IsSequence seq => ( Element seq -> Element seq -> Ordering ) -> seq -> seq Source #
defaultSplitWhen :: IsSequence seq => ( Element seq -> Bool ) -> seq -> [seq] Source #
Use
splitWhen
from
Data.List.Split
vectorSortBy :: Vector v e => (e -> e -> Ordering ) -> v e -> v e Source #
Sort a vector using an supplied element ordering function.
vectorSort :: ( Vector v e, Ord e) => v e -> v e Source #
Sort a vector.
defaultCons :: IsSequence seq => Element seq -> seq -> seq Source #
defaultSnoc :: IsSequence seq => seq -> Element seq -> seq Source #
tailDef :: IsSequence seq => seq -> seq Source #
initDef :: IsSequence seq => seq -> seq Source #
splitSeq :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> [seq] Source #
splits a sequence into components delimited by
separator subsequence.
splitSeq
splitSeq
is the right inverse of
intercalate
:
ointercalate x . splitSeq x === id
splitElem
can be considered a special case of
splitSeq
splitSeq (singleton sep) === splitElem sep
is another special case: it splits just before each
element, and in line with
splitSeq
mempty
splitWhen
rules, it has at least one output
component:
>splitSeq"" "" [""] >splitSeq"" "a" ["", "a"] >splitSeq"" "ab" ["", "a", "b"]
Since 0.9.3
replaceSeq :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> seq -> seq Source #
replaces all
replaceSeq
old new
old
subsequences with
new
.
replaceSeq old new === ointercalate new . splitSeq old
Since: 1.0.1
stripPrefix :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> Maybe seq Source #
stripPrefix
drops the given prefix from a sequence.
It returns
Nothing
if the sequence did not start with the prefix
given, or
Just
the sequence after the prefix, if it does.
>stripPrefix"foo" "foobar"Just"bar" >stripPrefix"abc" "foobar"Nothing
stripSuffix :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> Maybe seq Source #
stripSuffix
drops the given suffix from a sequence.
It returns
Nothing
if the sequence did not end with the suffix
given, or
Just
the sequence before the suffix, if it does.
>stripSuffix"bar" "foobar"Just"foo" >stripSuffix"abc" "foobar"Nothing
dropPrefix :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> seq Source #
dropPrefix
drops the given prefix from a sequence. It returns the
original sequence if the sequence doesn't start with the given prefix.
>dropPrefix"foo" "foobar" "bar" >dropPrefix"abc" "foobar" "foobar"
Since: 1.0.7.0
dropSuffix :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> seq Source #
dropSuffix
drops the given suffix from a sequence. It returns the
original sequence if the sequence doesn't end with the given suffix.
>dropSuffix"bar" "foobar" "foo" >dropSuffix"abc" "foobar" "foobar"
Since: 1.0.7.0
ensurePrefix :: ( Eq ( Element seq), IsSequence seq) => seq -> seq -> seq Source #
ensurePrefix
will add a prefix to a sequence if it doesn't
exist, and otherwise have no effect.
>ensurePrefix"foo" "foobar" "foobar" >ensurePrefix"abc" "foobar" "abcfoobar"
Since: 1.0.3
ensureSuffix :: ( Eq ( Element seq), IsSequence seq) => seq -> seq -> seq Source #
Append a suffix to a sequence, unless it already has that suffix.
>ensureSuffix"bar" "foobar" "foobar" >ensureSuffix"abc" "foobar" "foobarabc"
Since: 1.0.3
isPrefixOf :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> Bool Source #
isPrefixOf
takes two sequences and returns
True
if the first
sequence is a prefix of the second.
isSuffixOf :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> Bool Source #
isSuffixOf
takes two sequences and returns
True
if the first
sequence is a suffix of the second.
isInfixOf :: ( IsSequence seq, Eq ( Element seq)) => seq -> seq -> Bool Source #
isInfixOf
takes two sequences and returns
true
if the first
sequence is contained, wholly and intact, anywhere within the second.
groupAll :: ( IsSequence seq, Eq ( Element seq)) => seq -> [seq] Source #
Similar to standard
group
, but operates on the whole collection,
not just the consecutive items.
Equivalent to
groupAllOn
id
deleteBy :: ( IsSequence seq, Eq ( Element seq)) => ( Element seq -> Element seq -> Bool ) -> Element seq -> seq -> seq Source #
Since: 0.10.2
splitElemStrictBS :: Word8 -> ByteString -> [ ByteString ] Source #
splitSeqLazyBS :: Word8 -> ByteString -> [ ByteString ] Source #
stripPrefixLazyBS :: ByteString -> ByteString -> Maybe ByteString Source #
stripSuffixLazyBS :: ByteString -> ByteString -> Maybe ByteString Source #
sort :: ( SemiSequence seq, Ord ( Element seq)) => seq -> seq Source #
Sort a ordered sequence.
> sort [4,3,1,2]
[1,2,3,4]
class ( IsSequence t, IsString t, Element t ~ Char ) => Textual t where Source #
A typeclass for sequences whose elements are
Char
s.
Methods
Break up a textual sequence into a list of words, which were delimited by white space.
> words "abc def ghi"
["abc","def","ghi"]
unwords :: ( Element seq ~ t, MonoFoldable seq) => seq -> t Source #
Join a list of textual sequences using seperating spaces.
> unwords ["abc","def","ghi"]
"abc def ghi"
Break up a textual sequence at newline characters.
> lines "hello\nworld"
["hello","world"]
unlines :: ( Element seq ~ t, MonoFoldable seq) => seq -> t Source #
Join a list of textual sequences using newlines.
> unlines ["abc","def","ghi"]
"abc\ndef\nghi"
Convert a textual sequence to lower-case.
> toLower "HELLO WORLD"
"hello world"
Convert a textual sequence to upper-case.
> toUpper "hello world"
"HELLO WORLD"
toCaseFold :: t -> t Source #
Convert a textual sequence to folded-case.
Slightly different from
toLower
, see
Data.Text
.
toCaseFold
breakWord :: t -> (t, t) Source #
Split a textual sequence into two parts, split at the first space.
> breakWord "hello world"
("hello","world")
breakLine :: t -> (t, t) Source #
Split a textual sequence into two parts, split at the newline.
> breakLine "abc\ndef"
("abc","def")
Instances
catMaybes :: ( IsSequence (f ( Maybe t)), Functor f, Element (f ( Maybe t)) ~ Maybe t) => f ( Maybe t) -> f t Source #
Takes all of the
Just
values from a sequence of
Maybe t
s and
concatenates them into an unboxed sequence of
t
s.
Since 0.6.2
sortOn :: ( Ord o, SemiSequence seq) => ( Element seq -> o) -> seq -> seq Source #
Same as
sortBy . comparing
.
Since 0.7.0
class ( IsSequence lazy, IsSequence strict) => LazySequence lazy strict | lazy -> strict, strict -> lazy where Source #
Lazy sequences containing strict chunks of data.
Since: 1.0.0
Methods
toChunks :: lazy -> [strict] Source #
fromChunks :: [strict] -> lazy Source #
toStrict :: lazy -> strict Source #
fromStrict :: strict -> lazy Source #
Instances
| LazySequence ByteString ByteString Source # | |
|
Defined in Data.Sequences Methods toChunks :: ByteString0 -> [ ByteString ] Source # fromChunks :: [ ByteString ] -> ByteString0 Source # toStrict :: ByteString0 -> ByteString Source # fromStrict :: ByteString -> ByteString0 Source # |
|
| LazySequence Text Text Source # | |
repack :: ( MonoFoldable a, IsSequence b, Element a ~ Element b) => a -> b Source #
Repack from one type to another, dropping to a list in the middle.
repack = pack . unpack
.
Since: 1.0.0
class ( Textual textual, IsSequence binary) => Utf8 textual binary | textual -> binary, binary -> textual where Source #
Textual data which can be encoded to and decoded from UTF8.
Since: 1.0.0
Methods
encodeUtf8 :: textual -> binary Source #
Encode from textual to binary using UTF-8 encoding
Since: 1.0.0
decodeUtf8 :: binary -> textual Source #
Note that this function is required to be pure. In the case of a decoding error, Unicode replacement characters must be used.
Since: 1.0.0
Instances
| Utf8 Text ByteString Source # | |
|
Defined in Data.Sequences |
|
| Utf8 Text ByteString Source # | |
|
Defined in Data.Sequences |
|
| (c ~ Char , w ~ Word8 ) => Utf8 [c] [w] Source # | |
|
Defined in Data.Sequences |
|