Codec.Binary.UTF8.Generic

utf8-string-1.0.2: Support for reading and writing UTF8 Strings

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

Codec.Binary.UTF8.Generic

Description

Synopsis

- class (Num s, Ord s) => UTF8Bytes b s | b -> s where
  - bsplit :: s -> b -> (b, b)
  - bdrop :: s -> b -> b
  - buncons :: b -> Maybe (Word8, b)
  - elemIndex :: Word8 -> b -> Maybe s
  - empty :: b
  - null :: b -> Bool
  - pack :: [Word8] -> b
  - tail :: b -> b
- decode :: UTF8Bytes b s => b -> Maybe (Char, s)
- replacement_char :: Char
- uncons :: UTF8Bytes b s => b -> Maybe (Char, b)
- splitAt :: UTF8Bytes b s => s -> b -> (b, b)
- take :: UTF8Bytes b s => s -> b -> b
- drop :: UTF8Bytes b s => s -> b -> b
- span :: UTF8Bytes b s => (Char -> Bool) -> b -> (b, b)
- break :: UTF8Bytes b s => (Char -> Bool) -> b -> (b, b)
- fromString :: UTF8Bytes b s => String -> b
- toString :: UTF8Bytes b s => b -> String
- foldl :: UTF8Bytes b s => (a -> Char -> a) -> a -> b -> a
- foldr :: UTF8Bytes b s => (Char -> a -> a) -> a -> b -> a
- length :: UTF8Bytes b s => b -> s
- lines :: UTF8Bytes b s => b -> [b]
- lines' :: UTF8Bytes b s => b -> [b]

# Documentation

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

Methods

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

bdrop :: s -> b -> b #

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

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

empty :: b #

null :: b -> Bool #

pack :: [Word8] -> b #

tail :: b -> b #

#### Instances

Instances details

UTF8Bytes ByteString Int # |
Instance details Defined in Codec.Binary.UTF8.Generic Methods bsplit :: Int -> ByteString -> (ByteString, ByteString) # bdrop :: Int -> ByteString -> ByteString # buncons :: ByteString -> Maybe (Word8, ByteString) # elemIndex :: Word8 -> ByteString -> Maybe Int # empty :: ByteString # null :: ByteString -> Bool # pack :: [Word8] -> ByteString # tail :: ByteString -> ByteString #
UTF8Bytes ByteString Int64 # |
Instance details Defined in Codec.Binary.UTF8.Generic Methods bsplit :: Int64 -> ByteString -> (ByteString, ByteString) # bdrop :: Int64 -> ByteString -> ByteString # buncons :: ByteString -> Maybe (Word8, ByteString) # elemIndex :: Word8 -> ByteString -> Maybe Int64 # empty :: ByteString # null :: ByteString -> Bool # pack :: [Word8] -> ByteString # tail :: ByteString -> ByteString #
UTF8Bytes [Word8] Int # |
Instance details Defined in Codec.Binary.UTF8.Generic Methods bsplit :: Int -> [Word8] -> ([Word8], [Word8]) # bdrop :: Int -> [Word8] -> [Word8] # buncons :: [Word8] -> Maybe (Word8, [Word8]) # elemIndex :: Word8 -> [Word8] -> Maybe Int # empty :: [Word8] # null :: [Word8] -> Bool # pack :: [Word8] -> [Word8] # tail :: [Word8] -> [Word8] #

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

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 #

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

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

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

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

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

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

`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 #

`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) #

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) #

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 #

Converts a Haskell string into a UTF8 encoded bytestring.

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

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

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

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

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

Traverse a bytestring (right biased).

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

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

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

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] #

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`.