Data.String.Class

Documentation

class (StringCells s, StringRWIO s) => Stringy s

String super class

Instances

(StringCells s, StringRWIO s) => Stringy s

class (Eq s, Monoid s, IsString s, Typeable s, StringCell (StringCellChar s), StringCell (StringCellAltChar s), ConvGenString s, ConvString s, ConvStrictByteString s, ConvLazyByteString s, ConvText s) => StringCells s where

Minimal complete definition: StringCellChar; StringCellAltChar; toStringCells; fromStringCells; toMainChar; toAltChar; cons; snoc; either all of head, tail, last, and init, or all of uncons and unsnoc; take, take64 or genericTake; drop, drop64, or genericDrop; and length, length64, or genericLength

Associated Types

type StringCellChar s

type StringCellAltChar s

Methods

toStringCells :: StringCells s2 => s -> s2

fromStringCells :: StringCells s2 => s2 -> s

cons :: StringCellChar s -> s -> s

uncons :: s -> (StringCellChar s, s)

snoc :: s -> StringCellChar s -> s

unsnoc :: s -> (s, StringCellChar s)

altCons :: StringCellAltChar s -> s -> s

altUncons :: s -> (StringCellAltChar s, s)

altSnoc :: s -> StringCellAltChar s -> s

altUnsnoc :: s -> (s, StringCellAltChar s)

toMainChar :: StringCell c => c -> Tagged s (StringCellChar s)

toAltChar :: StringCell c => c -> Tagged s (StringCellAltChar s)

append :: s -> s -> s

Append two strings

concat :: [s] -> s

empty :: s

null :: s -> Bool

head :: s -> StringCellChar s

tail :: s -> s

last :: s -> StringCellChar s

init :: s -> s

altHead :: s -> StringCellAltChar s

altLast :: s -> StringCellAltChar s

unfoldr :: (a -> Maybe (StringCellChar s, a)) -> a -> s

Construction of a string; implementations should behave safely with incorrect lengths

The default implementation of undfoldr is independent from that of altUnfoldr, as well as unfoldrN as and altUnfoldrN.

altUnfoldr :: (a -> Maybe (StringCellAltChar s, a)) -> a -> s

unfoldrN :: Int -> (a -> Maybe (StringCellChar s, a)) -> a -> s

altUnfoldrN :: Int -> (a -> Maybe (StringCellAltChar s, a)) -> a -> s

index :: s -> Int -> StringCellChar s

Get the character at the given position

Just like drop, drop64, and the variants of those functions, the default definitions of these three variants are independent of each other, and are defined in terms of head and tail, which can be inefficient.

index64 :: s -> Int64 -> StringCellChar s

genericIndex :: Integral i => s -> i -> StringCellChar s

Index a string at any location

Just like the other generic functions of this module, this function can be significantly slower than index, since the function must be able to support arbitrarily large indices. Consider using index or index64, even if you need to coerce the index to an Int.

take :: Int -> s -> s

take64 :: Int64 -> s -> s

genericTake :: Integral i => i -> s -> s

drop :: Int -> s -> s

drop64 :: Int64 -> s -> s

genericDrop :: Integral i => i -> s -> s

length :: s -> Int

length64 :: s -> Int64

genericLength :: Integral i => s -> i

safeUncons :: s -> Maybe (StringCellChar s, s)

safeUnsnoc :: s -> Maybe (s, StringCellChar s)

safeAltUncons :: s -> Maybe (StringCellAltChar s, s)

safeAltUnsnoc :: s -> Maybe (s, StringCellAltChar s)

safeHead :: s -> Maybe (StringCellChar s)

safeTail :: s -> Maybe s

safeLast :: s -> Maybe (StringCellChar s)

safeInit :: s -> Maybe s

safeAltHead :: s -> Maybe (StringCellAltChar s)

safeAltLast :: s -> Maybe (StringCellAltChar s)

safeIndex :: s -> Int -> Maybe (StringCellChar s)

safeIndex64 :: s -> Int64 -> Maybe (StringCellChar s)

safeGenericIndex :: Integral i => s -> i -> Maybe (StringCellChar s)

safeTake :: Int -> s -> Maybe s

safeTake64 :: Int64 -> s -> Maybe s

safeGenericTake :: Integral i => i -> s -> Maybe s

safeDrop :: Int -> s -> Maybe s

safeDrop64 :: Int64 -> s -> Maybe s

safeGenericDrop :: Integral i => i -> s -> Maybe s

safeUncons2 :: s -> Maybe (StringCellChar s, StringCellChar s, s)

safeUncons3 :: s -> Maybe (StringCellChar s, StringCellChar s, StringCellChar s, s)

safeUncons4 :: s -> Maybe (StringCellChar s, StringCellChar s, StringCellChar s, StringCellChar s, s)

cons2 :: StringCellChar s -> StringCellChar s -> s -> s

cons3 :: StringCellChar s -> StringCellChar s -> StringCellChar s -> s -> s

cons4 :: StringCellChar s -> StringCellChar s -> StringCellChar s -> StringCellChar s -> s -> s

uncons2 :: s -> (StringCellChar s, StringCellChar s, s)

uncons3 :: s -> (StringCellChar s, StringCellChar s, StringCellChar s, s)

uncons4 :: s -> (StringCellChar s, StringCellChar s, StringCellChar s, StringCellChar s, s)

Instances

StringCells String

StringCells ByteString

StringCells ByteString

StringCells Text

StringCells GenString

class StringCell c where

Methods

toChar :: c -> Char

toWord8 :: c -> Word8

toWord16 :: c -> Word16

toWord32 :: c -> Word32

toWord64 :: c -> Word64

fromChar :: Char -> c

fromWord8 :: Word8 -> c

fromWord16 :: Word16 -> c

fromWord32 :: Word32 -> c

fromWord64 :: Word64 -> c

Instances

StringCell Char

StringCell Word8

StringCell Word16

StringCell Word32

StringCell Word64

class StringRWIO s where

Minimal complete definition: hGetContents, hGetLine, hPutStr, and hPutStrLn

Methods

hGetContents :: Handle -> IO s

Read n bytes *or* characters, depending on the implementation into a ByteString, directly from the specified Handle

Whether or not this function is lazy depends on the instance; laziness is preferred.

hGetLine :: Handle -> IO s

Read a single line from a handle

hPutStr :: Handle -> s -> IO ()

Write a string to a handle

hPutStrLn :: Handle -> s -> IO ()

Write a string to a handle, followed by a newline

N.B.: implementations might not define this atomically. If the state of being atomic is necessary, one possible solution is to convert a string to an efficient type for which hPutStrLn is atomic.

interact :: (s -> s) -> IO ()

Take a function of type Text -> Text as its argument

The entire input from the standard input device is passed to this function as its argument, and the resulting string is output on the standard output device.

getContents :: IO s

Read all user input on stdin as a single string

getLine :: IO s

Read a single line of user input from stdin

putStr :: s -> IO ()

Write a string to stdout

putStrLn :: s -> IO ()

Write a string to stdout, followed by a newline

readFile :: FilePath -> IO s

Read a file and returns the contents of the file as a string

Depending on the instance, this function might expect the file to be non-binary. The default definition uses openFile to open the file.

writeFile :: FilePath -> s -> IO ()

Write a string to a file

The file is truncated to zero length before writing begins. The default definition uses withFile to open the file.

appendFile :: FilePath -> s -> IO ()

Write a string to the end of a file

The default definition uses withFile to open the file.

Instances

StringRWIO String

See 'System.IO for documentation of behaviour.

StringRWIO ByteString

See Lazy for documentation of behaviour.

hGetLine and getLine are defined in terms of toStringCells and the equivalent methods of ByteString. hPutStrLn is defined non-atomically: it is defined as an action that puts the string and then separately puts a newline character string.

StringRWIO ByteString

See ByteString for documentation of behaviour.

StringRWIO Text

See IO for documentation of behaviour.

StringRWIO GenString

This is minimally defined with GenStringDefault.

class ConvGenString s where

Methods

toGenString :: s -> GenString

fromGenString :: GenString -> s

Instances

ConvGenString String

ConvGenString ByteString

ConvGenString ByteString

ConvGenString Text

ConvGenString GenString

class ConvString s where

Methods

toString :: s -> String

fromString :: String -> s

Instances

ConvString String

ConvString ByteString

ConvString ByteString

ConvString Text

ConvString GenString

class ConvStrictByteString s where

Methods

toStrictByteString :: s -> ByteString

fromStrictByteString :: ByteString -> s

Instances

ConvStrictByteString String

ConvStrictByteString ByteString

ConvStrictByteString ByteString

ConvStrictByteString Text

ConvStrictByteString GenString

class ConvLazyByteString s where

Methods

toLazyByteString :: s -> ByteString

fromLazyByteString :: ByteString -> s

Instances

ConvLazyByteString String

ConvLazyByteString ByteString

ConvLazyByteString ByteString

ConvLazyByteString Text

ConvLazyByteString GenString

class ConvText s where

Methods

toText :: s -> Text

fromText :: Text -> s

Instances

ConvText String

ConvText ByteString

ConvText ByteString

ConvText Text

ConvText GenString

data GenString

Polymorphic container of a string

When operations take place on multiple GenStrings, they are first converted to the type GenStringDefault, which are lazy bytestrings, whenever absolutely necessary (which includes testing for equality, appending strings, concatenating lists of strings, empty strings with empty, and unfolding), making them the most efficient type for this polymorphic container.

Constructors

forall s . Stringy s => GenString

Fields

gen_string :: s

Instances

Eq GenString

Typeable GenString

IsString GenString

Monoid GenString

StringRWIO GenString

This is minimally defined with GenStringDefault.

ConvText GenString

ConvLazyByteString GenString

ConvStrictByteString GenString

ConvString GenString

ConvGenString GenString

StringCells GenString

type GenStringDefault = ByteString

This type is used by GenString when a concrete string type is needed