| 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 #
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 #
intersperse takes an element and intersperses that element between
the elements of the sequence.
> intersperse ',' "abcde"
"a,b,c,d,e"
Reverse a sequence
> reverse "hello world"
"dlrow olleh"
find :: (Element seq -> Bool) -> seq -> Maybe (Element seq) #
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 #
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 #
Prepend an element onto a sequence.
> 4 `cons` [1,2,3]
[4,1,2,3]
snoc :: seq -> Element seq -> seq #
Append an element onto a sequence.
> [1,2,3] `snoc` 4
[1,2,3,4]
Instances
singleton :: MonoPointed seq => Element seq -> seq #
class (Monoid seq, MonoTraversable seq, SemiSequence seq, MonoPointed seq) => IsSequence seq where #
Sequence Laws:
fromList.otoList=idfromList(x <> y) =fromListx <>fromListyotoList(fromListx <>fromListy) = x <> y
Minimal complete definition
Nothing
Methods
fromList :: [Element seq] -> seq #
Convert a list to a sequence.
>fromList[a,b,c] :: Text "abc"
lengthIndex :: seq -> Index seq #
lengthIndex returns the length of a sequence as Index seq
Since: 1.0.2
break :: (Element seq -> Bool) -> seq -> (seq, seq) #
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.
break pspan (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) #
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.
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 #
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 #
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) #
splitAt n sese 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) #
Equivalent to splitAt.
take :: Index seq -> seq -> seq #
take nn, 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 #
Equivalent to take.
drop :: Index seq -> seq -> seq #
drop nn
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 #
Equivalent to drop
dropEnd :: Index seq -> seq -> seq #
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) #
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) #
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) #
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 #
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 #
The monadic version of filter.
replicate :: Index seq -> Element seq -> seq #
replicate n xn with x as the
value of every element.
>replicate10a:: Text "aaaaaaaaaa"
replicateM :: Monad m => Index seq -> m (Element seq) -> m seq #
The monadic version of replicateM.
groupBy :: (Element seq -> Element seq -> Bool) -> seq -> [seq] #
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] #
Similar to standard groupBy, but operates on the whole collection,
not just the consecutive items.
subsequences :: seq -> [seq] #
subsequences returns a list of all subsequences of the argument.
> subsequences "abc"
["","a","b","ab","c","ac","bc","abc"]
permutations :: seq -> [seq] #
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]
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 #
Safe version of initEx.
Returns Nothing instead of throwing an exception when encountering
an empty monomorphic container.
Since: 1.0.0
unsafeTail :: seq -> seq #
Equivalent to tailEx.
unsafeInit :: seq -> seq #
Equivalent to initEx.
index :: seq -> Index seq -> Maybe (Element seq) #
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 #
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 #
Equivalent to indexEx.
splitWhen :: (Element seq -> Bool) -> seq -> [seq] #
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) #
defaultIntersperse :: IsSequence seq => Element seq -> seq -> seq #
Use Data.List's implementation of intersperse.
defaultReverse :: IsSequence seq => seq -> seq #
defaultSortBy :: IsSequence seq => (Element seq -> Element seq -> Ordering) -> seq -> seq #
defaultSplitWhen :: IsSequence seq => (Element seq -> Bool) -> seq -> [seq] #
Use splitWhen from Data.List.Split
vectorSortBy :: Vector v e => (e -> e -> Ordering) -> v e -> v e #
Sort a vector using an supplied element ordering function.
vectorSort :: (Vector v e, Ord e) => v e -> v e #
Sort a vector.
defaultCons :: IsSequence seq => Element seq -> seq -> seq #
defaultSnoc :: IsSequence seq => seq -> Element seq -> seq #
tailDef :: IsSequence seq => seq -> seq #
initDef :: IsSequence seq => seq -> seq #
splitSeq :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> [seq] #
splitSeqsplitSeq 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
splitSeq memptysplitWhen 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 #
replaceSeq old newold subsequences with new.
replaceSeq old new === ointercalate new . splitSeq old
Since: 1.0.1
stripPrefix :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> Maybe seq #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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] #
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 #
Since: 0.10.2
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] #
splitSeqLazyText :: Text -> Text -> [Text] #
sort :: (SemiSequence seq, Ord (Element seq)) => seq -> seq #
Sort a ordered sequence.
> sort [4,3,1,2]
[1,2,3,4]
class (IsSequence t, IsString t, Element t ~ Char) => Textual t where #
A typeclass for sequences whose elements are Chars.
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 #
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 #
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 #
Convert a textual sequence to folded-case.
Slightly different from toLower, see Data.Text.toCaseFold
Split a textual sequence into two parts, split at the first space.
> breakWord "hello world"
("hello","world")
Split a textual sequence into two parts, split at the newline.
> breakLine "abc\ndef"
("abc","def")
Instances
| Textual Text # | |
| Textual Text # | |
| c ~ Char => Textual [c] # | |
Defined in Data.Sequences Methods unwords :: (Element seq ~ [c], MonoFoldable seq) => seq -> [c] # unlines :: (Element seq ~ [c], MonoFoldable seq) => seq -> [c] # toCaseFold :: [c] -> [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.
Since 0.7.0
class (IsSequence lazy, IsSequence strict) => LazySequence lazy strict | lazy -> strict, strict -> lazy where #
Lazy sequences containing strict chunks of data.
Since: 1.0.0
Instances
| LazySequence ByteString ByteString # | |
Defined in Data.Sequences Methods toChunks :: ByteString0 -> [ByteString] # fromChunks :: [ByteString] -> ByteString0 # toStrict :: ByteString0 -> ByteString # fromStrict :: ByteString -> ByteString0 # | |
| LazySequence Text Text # | |
pack :: IsSequence seq => [Element seq] -> seq #
Synonym for fromList
Since: 1.0.0
unpack :: MonoFoldable mono => mono -> [Element mono] #
Synonym for otoList
Since: 1.0.0
repack :: (MonoFoldable a, IsSequence b, Element a ~ Element b) => a -> b #
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 #
Textual data which can be encoded to and decoded from UTF8.
Since: 1.0.0
Methods
encodeUtf8 :: textual -> binary #
Encode from textual to binary using UTF-8 encoding
Since: 1.0.0
decodeUtf8 :: binary -> textual #
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 # | |
Defined in Data.Sequences | |
| Utf8 Text ByteString # | |
Defined in Data.Sequences | |
| (c ~ Char, w ~ Word8) => Utf8 [c] [w] # | |
Defined in Data.Sequences | |