Data.Strings

Functions for working with strings, including Text, ByteString, etc.

This module aims at offering a consistent interface across all the available string types. It currently offers instances for the ordinary Haskell String type, Text, lazy Text, ByteString, and lazy ByteString.

It especially provides functions for some types, which are otherwise not available nativly (such as breakOnSubstring which is not available for the lazy Text type, is offered by sBreak and strBreak).

Documentation

text :: String -> Text

Create a Text object form an ordinary Haskell String.

lazyText :: String -> Text

Create a lazy Text object from an ordinary Haskell String.

bytes :: String -> ByteString

Create a ByteString object form an ordinary Haskell String. This function will encode a String using the UTF-8 character encoding.

lazyBytes :: String -> ByteString

Create a lazy ByteString object from an ordinary Haskell String. This function will encode a String using the UTF-8 character encoding.

charToByte :: Char -> Word8

Convert a Char into a Word8.

byteToChar :: Word8 -> Char

Convert a Word8 into a Char.

class (Eq a, Strings a) => Str a where

The Str class provides functions for working with arbitrary Strings. It is basically the same interface as provided by the Strings class. However, every input string is a Haskell String here, thus easing the usage of different string types with native Haskell String literals.

For example strAppend suffix works with any string type for which an instance of Str is defined. In order to maximize the ease of use of this library, the functions are prefixed with str.

The complexity and efficiency of these functions depends on the underlying string type being used.

Minimal complete definition: It suffices to provide instances for Eq and Strings.

Methods

strNull :: a -> Bool

Check whether the given string is empty or not. null generalised.

strLen :: a -> Int

length generalised.

strHead :: a -> Char

head generalised. This function is undefined if strNull would return True.

strLast :: a -> Char

last generalised. This function is undefined if strNull would return True.

strInit :: a -> a

init generalised. This function is undefined if strNull would return True.

strTail :: a -> a

tail generalised. This function is undefined if strNull would return True.

strTake :: Int -> a -> a

take generalised.

strDrop :: Int -> a -> a

drop generalised.

strReplace

Arguments

:: String

Needle.

-> String

Replacement.

-> a

Haystack.

-> a

Result: Haystack with Needle replaced by Replacement.

Replace a substring with another string.

strBreak :: String -> a -> (a, a)

Breaks the string on the first occurence of the given substring.

 strBreak "xx" "1x2xx3xx4" = ("1x2", "xx3xx4")

strSplit :: String -> a -> (a, a)

Like strBreak, but the string to break on is excluded from the result.

 strSplit "xx" "1x2xx3xx4" = ("1x2", "3xx4")

strSplitAll :: String -> a -> [a]

Split a string into multiple fragments, separated by the given substring.

 strSplitAll "xx" "1x2xx3xx4" = ["1x2", "3", "4"]

strToUpper :: a -> a

Turn all characters in the string to upper case.

strToLower :: a -> a

Turn all characters in the string to lower case.

strCapitalize :: a -> a

Turn the first character in the string to upper case.

strMap :: (Char -> Char) -> a -> a

map generalised.

strConcat :: [a] -> a

concat generalised.

strJoin :: String -> [a] -> a

Glue together multiple strings by a given Haskell String.

 strJoin x = concat . intersperse x

strAppend :: String -> a -> a

Appends the given Haskell String to the string. ++ generalised.

 strAppend " world" "hello" = "hello world"

strCons :: Char -> a -> a

Cons generalised.

strTrim :: a -> a

Strips white space characters off both ends of the string.

strPadLeft :: Char -> Int -> a -> a

Appends the given character n times to the left, such that the resulting string has the given length.

 strPadLeft '0' 8 "4711" == "00004711"

strPadRight :: Char -> Int -> a -> a

Appends the given character n times to the right, such that the resulting string has the given length.

 strPadRight '0' 8 "4711" == "47110000"

strPadBoth :: Char -> Int -> a -> a

Appends the given character n times to both sides, such that the resulting string has the given length.

 strPadBoth '0' 8 "4711" == "00471100"

strReverse :: a -> a

Reverse the string.

strEq

Arguments

:: String

The Haskell String.

-> a

The string.

-> Bool

Check if the given Haskell String equals the string.

strStartsWith :: a -> String -> Bool

Check if the string starts with the given Haskell String.

strEndsWith :: a -> String -> Bool

Check if the string ends with the given Haskell String.

fromString :: String -> a

Create a string from a Haskell String.

fromUnicodeString :: String -> a

Create a string from a Haskell String. If the string does not support unicode, the Haskell String is encoded using UTF-8.

toString :: a -> String

Convert the string into a Haskell String.

toWord8 :: a -> [Word8]

Convert the string into a list of bytes.

Instances

Str String

Str ByteString

Str ByteString

Str Text

Str Text

class Strings a where

The goal of this class is to offer the same interface for various types of strings (ByteString, Text, Haskell String, etc.). If a certain type offers a native implementation for a given function, Strings uses it. If not, a default implementation is given.

All of these functions are prefixed with s to avoid nameclashes with existing functions from the prelude.

The complexity and efficiency of these functions depends on the underlying string type being used.

Methods

sNull :: a -> Bool

Check whether the given string is empty or not. null generalised.

sEmpty :: a

The empty string.

sLen :: a -> Int

length generalised.

sHead :: a -> Char

head generalised. This function is undefined if strNull would return True.

sLast :: a -> Char

last generalised. This function is undefined if strNull would return True.

sInit :: a -> a

init generalised. This function is undefined if strNull would return True.

sTail :: a -> a

tail generalised. This function is undefined if strNull would return True.

sTake :: Int -> a -> a

take generalised.

sDrop :: Int -> a -> a

drop generalised.

sTakeWhile :: (Char -> Bool) -> a -> a

takeWhile generalised.

sDropWhile :: (Char -> Bool) -> a -> a

dropWhile generalised.

sReplace :: a -> a -> a -> a

Replace a substring with another string.

sBreak :: a -> a -> (a, a)

Breaks the string on the first occurence of the given substring.

 strBreak "xx" "1x2xx3xx4" = ("1x2", "xx3xx4")

sSplit :: a -> a -> (a, a, Bool)

Like sBreak, but the string to break on is excluded from the result.

 strSplit "xx" "1x2xx3xx4" = ("1x2", "3xx4")

sSplitAll :: a -> a -> [a]

Split a string into multiple fragments, separated by the given substring.

 strSplitAll "xx" "1x2xx3xx4" = ["1x2", "3", "4"]

sStartsWith :: a -> a -> Bool

Check if the string starts with the given string.

sEndsWith :: a -> a -> Bool

Check if the string ends with the given string.

sCons :: Char -> a -> a

Cons

sCapitalize :: a -> a

Turn the first character into an upper case character.

sMap :: (Char -> Char) -> a -> a

Map a function over all characters.

sConcat :: [a] -> a

Concatenate all the strings in the list to a single string.

sTrim :: a -> a

Strips white space characters off both ends of the string.

sPadLeft :: Char -> Int -> a -> a

Appends the given character n times to the left, such that the resulting string has the given length.

 strPadLeft '0' 8 "4711" == "00004711"

sPadRight :: Char -> Int -> a -> a

Appends the given character n times to the right, such that the resulting string has the given length.

 strPadRight '0' 8 "4711" == "47110000"

sPadBoth :: Char -> Int -> a -> a

Appends the given character n times to both sides, such that the resulting string has the given length.

 strPadBoth '0' 8 "4711" == "00471100"

sReverse :: a -> a

sFromString :: String -> a

Create a string from a Haskell String.

sFromUnicodeString :: String -> a

Create a string from a Haskell String. If the string does not support unicode, the Haskell String is encoded using UTF-8.

sToString :: a -> String

Convert the string into a Haskell String.

sToWord8 :: a -> [Word8]

Convert the string into a list of bytes.

Instances

Strings String

Strings ByteString

Strings ByteString

Strings Text

Strings Text