string-class-0.1.5.1: String class library

Data.String.Class

Synopsis

Documentation

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

String super class

Instances

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 whereSource

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 Source

type StringCellAltChar s Source

Methods

toStringCells :: StringCells s2 => s -> s2Source

fromStringCells :: StringCells s2 => s2 -> sSource

cons :: StringCellChar s -> s -> sSource

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

snoc :: s -> StringCellChar s -> sSource

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

altCons :: StringCellAltChar s -> s -> sSource

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

altSnoc :: s -> StringCellAltChar s -> sSource

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

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

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

append :: s -> s -> sSource

Append two strings

concat :: [s] -> sSource

empty :: sSource

null :: s -> BoolSource

head :: s -> StringCellChar sSource

tail :: s -> sSource

last :: s -> StringCellChar sSource

init :: s -> sSource

altHead :: s -> StringCellAltChar sSource

altLast :: s -> StringCellAltChar sSource

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

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 -> sSource

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

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

index :: s -> Int -> StringCellChar sSource

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 sSource

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

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 -> sSource

take64 :: Int64 -> s -> sSource

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

drop :: Int -> s -> sSource

drop64 :: Int64 -> s -> sSource

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

length :: s -> IntSource

length64 :: s -> Int64Source

genericLength :: Integral i => s -> iSource

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

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

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

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

safeHead :: s -> Maybe (StringCellChar s)Source

safeTail :: s -> Maybe sSource

safeLast :: s -> Maybe (StringCellChar s)Source

safeInit :: s -> Maybe sSource

safeAltHead :: s -> Maybe (StringCellAltChar s)Source

safeAltLast :: s -> Maybe (StringCellAltChar s)Source

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

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

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

safeTake :: Int -> s -> Maybe sSource

safeTake64 :: Int64 -> s -> Maybe sSource

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

safeDrop :: Int -> s -> Maybe sSource

safeDrop64 :: Int64 -> s -> Maybe sSource

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

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

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

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

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

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

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

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

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

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

class StringRWIO s whereSource

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

Methods

hGetContents :: Handle -> IO sSource

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 sSource

Read a single line from a handle

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

Write a string to a handle

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

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 ()Source

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 sSource

Read all user input on stdin as a single string

getLine :: IO sSource

Read a single line of user input from stdin

putStr :: s -> IO ()Source

Write a string to stdout

putStrLn :: s -> IO ()Source

Write a string to stdout, followed by a newline

readFile :: FilePath -> IO sSource

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 ()Source

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 ()Source

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 Data.ByteString.Lazy for documentation of behaviour.

hGetLine and getLine are defined in terms of toStringCells and the equivalent methods of Data.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 Data.ByteString for documentation of behaviour.

StringRWIO Text

See Data.Text.IO for documentation of behaviour.

StringRWIO GenString

This is minimally defined with GenStringDefault.

data GenString Source

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
 

type GenStringDefault = ByteStringSource

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