ListLike-4.5: Generic support for list-like structures

Safe HaskellSafe
LanguageHaskell98

Data.ListLike.Text.Text

Contents

Documentation

Orphan instances

StringLike Text # 

Methods

toString :: Text -> String #

fromString :: String -> Text #

lines :: ListLike full Text => Text -> full #

words :: ListLike full Text => Text -> full #

unlines :: ListLike full Text => full -> Text #

unwords :: ListLike full Text => full -> Text #

FoldableLL Text Char # 

Methods

foldl :: (a -> Char -> a) -> a -> Text -> a #

foldl' :: (a -> Char -> a) -> a -> Text -> a #

foldl1 :: (Char -> Char -> Char) -> Text -> Char #

foldr :: (Char -> b -> b) -> b -> Text -> b #

foldr' :: (Char -> b -> b) -> b -> Text -> b #

foldr1 :: (Char -> Char -> Char) -> Text -> Char #

ListLike Text Char # 

Methods

empty :: Text #

singleton :: Char -> Text #

cons :: Char -> Text -> Text #

snoc :: Text -> Char -> Text #

append :: Text -> Text -> Text #

head :: Text -> Char #

uncons :: Text -> Maybe (Char, Text) #

last :: Text -> Char #

tail :: Text -> Text #

init :: Text -> Text #

null :: Text -> Bool #

length :: Text -> Int #

map :: ListLike full' item' => (Char -> item') -> Text -> full' #

rigidMap :: (Char -> Char) -> Text -> Text #

reverse :: Text -> Text #

intersperse :: Char -> Text -> Text #

concat :: (ListLike full' Text, Monoid Text) => full' -> Text #

concatMap :: ListLike full' item' => (Char -> full') -> Text -> full' #

rigidConcatMap :: (Char -> Text) -> Text -> Text #

any :: (Char -> Bool) -> Text -> Bool #

all :: (Char -> Bool) -> Text -> Bool #

maximum :: Text -> Char #

minimum :: Text -> Char #

replicate :: Int -> Char -> Text #

take :: Int -> Text -> Text #

drop :: Int -> Text -> Text #

splitAt :: Int -> Text -> (Text, Text) #

takeWhile :: (Char -> Bool) -> Text -> Text #

dropWhile :: (Char -> Bool) -> Text -> Text #

dropWhileEnd :: (Char -> Bool) -> Text -> Text #

span :: (Char -> Bool) -> Text -> (Text, Text) #

break :: (Char -> Bool) -> Text -> (Text, Text) #

group :: (ListLike full' Text, Eq Char) => Text -> full' #

inits :: ListLike full' Text => Text -> full' #

tails :: ListLike full' Text => Text -> full' #

isPrefixOf :: Text -> Text -> Bool #

isSuffixOf :: Text -> Text -> Bool #

isInfixOf :: Text -> Text -> Bool #

stripPrefix :: Text -> Text -> Maybe Text #

stripSuffix :: Text -> Text -> Maybe Text #

elem :: Char -> Text -> Bool #

notElem :: Char -> Text -> Bool #

find :: (Char -> Bool) -> Text -> Maybe Char #

filter :: (Char -> Bool) -> Text -> Text #

partition :: (Char -> Bool) -> Text -> (Text, Text) #

index :: Text -> Int -> Char #

elemIndex :: Char -> Text -> Maybe Int #

elemIndices :: (Eq Char, ListLike result Int) => Char -> Text -> result #

findIndex :: (Char -> Bool) -> Text -> Maybe Int #

findIndices :: ListLike result Int => (Char -> Bool) -> Text -> result #

sequence :: (Monad m, ListLike fullinp (m Char)) => fullinp -> m Text #

mapM :: (Monad m, ListLike full' item') => (Char -> m item') -> Text -> m full' #

rigidMapM :: Monad m => (Char -> m Char) -> Text -> m Text #

nub :: Text -> Text #

delete :: Char -> Text -> Text #

deleteFirsts :: Text -> Text -> Text #

union :: Text -> Text -> Text #

intersect :: Text -> Text -> Text #

sort :: Text -> Text #

insert :: Char -> Text -> Text #

toList :: Text -> [Char] #

fromList :: [Char] -> Text #

fromListLike :: ListLike full' Char => Text -> full' #

nubBy :: (Char -> Char -> Bool) -> Text -> Text #

deleteBy :: (Char -> Char -> Bool) -> Char -> Text -> Text #

deleteFirstsBy :: (Char -> Char -> Bool) -> Text -> Text -> Text #

unionBy :: (Char -> Char -> Bool) -> Text -> Text -> Text #

intersectBy :: (Char -> Char -> Bool) -> Text -> Text -> Text #

groupBy :: (ListLike full' Text, Eq Char) => (Char -> Char -> Bool) -> Text -> full' #

sortBy :: (Char -> Char -> Ordering) -> Text -> Text #

insertBy :: (Char -> Char -> Ordering) -> Char -> Text -> Text #

genericLength :: Num a => Text -> a #

genericTake :: Integral a => a -> Text -> Text #

genericDrop :: Integral a => a -> Text -> Text #

genericSplitAt :: Integral a => a -> Text -> (Text, Text) #

genericReplicate :: Integral a => a -> Char -> Text #

ListLikeIO Text Char #