Copyright	(c) Iavor S. Diatchki 2009
License	BSD3-style (see LICENSE)
Maintainer	emertens@galois.com
Stability	experimental
Portability	portable
Safe Haskell	Trustworthy
Language	Haskell98

Codec.Binary.UTF8.Generic

Description

Synopsis

Documentation

class (Num s, Ord s) => UTF8Bytes b s | b -> s where Source

Methods

bsplit :: s -> b -> (b, b) Source

bdrop :: s -> b -> b Source

buncons :: b -> Maybe (Word8, b) Source

elemIndex :: Word8 -> b -> Maybe s Source

empty :: b Source

null :: b -> Bool Source

pack :: [Word8] -> b Source

tail :: b -> b Source

Instances

UTF8Bytes ByteString Int64 Source
UTF8Bytes ByteString Int Source
UTF8Bytes [Word8] Int Source

decode :: UTF8Bytes b s => b -> Maybe (Char, s) Source

Try to extract a character from a byte string. Returns Nothing if there are no more bytes in the byte string. Otherwise, it returns a decoded character and the number of bytes used in its representation. Errors are replaced by character '\0xFFFD'.

replacement_char :: Char Source

This character is used to mark errors in a UTF8 encoded string.

uncons :: UTF8Bytes b s => b -> Maybe (Char, b) Source

Get the first character of a byte string, if any. Malformed characters are replaced by '\0xFFFD'.

splitAt :: UTF8Bytes b s => s -> b -> (b, b) Source

Split after a given number of characters. Negative values are treated as if they are 0.

take :: UTF8Bytes b s => s -> b -> b Source

take n s returns the first n characters of s. If s has less than n characters, then we return the whole of s.

drop :: UTF8Bytes b s => s -> b -> b Source

drop n s returns the s without its first n characters. If s has less than n characters, then we return an empty string.

span :: UTF8Bytes b s => (Char -> Bool) -> b -> (b, b) Source

Split a string into two parts: the first is the longest prefix that contains only characters that satisfy the predicate; the second part is the rest of the string. Invalid characters are passed as '\0xFFFD' to the predicate.

break :: UTF8Bytes b s => (Char -> Bool) -> b -> (b, b) Source

Split a string into two parts: the first is the longest prefix that contains only characters that do not satisfy the predicate; the second part is the rest of the string. Invalid characters are passed as '\0xFFFD' to the predicate.

fromString :: UTF8Bytes b s => String -> b Source

Converts a Haskell string into a UTF8 encoded bytestring.

toString :: UTF8Bytes b s => b -> String Source

Convert a UTF8 encoded bytestring into a Haskell string. Invalid characters are replaced with '\xFFFD'.

foldl :: UTF8Bytes b s => (a -> Char -> a) -> a -> b -> a Source

Traverse a bytestring (left biased). This function is strict in the accumulator.

foldr :: UTF8Bytes b s => (Char -> a -> a) -> a -> b -> a Source

Traverse a bytestring (right biased).

length :: UTF8Bytes b s => b -> s Source

Counts the number of characters encoded in the bytestring. Note that this includes replacement characters.

lines :: UTF8Bytes b s => b -> [b] Source

Split a string into a list of lines. Lines are terminated by '\n' or the end of the string. Empty lines may not be terminated by the end of the string. See also 'lines\''.

lines' :: UTF8Bytes b s => b -> [b] Source

Split a string into a list of lines. Lines are terminated by '\n' or the end of the string. Empty lines may not be terminated by the end of the string. This function preserves the terminators. See also lines.