Documentation

Methods

(==) :: Chars -> Chars -> Bool #

(/=) :: Chars -> Chars -> Bool #

Methods

compare :: Chars -> Chars -> Ordering #

(<) :: Chars -> Chars -> Bool #

(<=) :: Chars -> Chars -> Bool #

(>) :: Chars -> Chars -> Bool #

(>=) :: Chars -> Chars -> Bool #

max :: Chars -> Chars -> Chars #

min :: Chars -> Chars -> Chars #

Methods

showsPrec :: Int -> Chars -> ShowS #

show :: Chars -> String #

showList :: [Chars] -> ShowS #

Methods

fromString :: String -> Chars #

Methods

(<>) :: Chars -> Chars -> Chars #

sconcat :: NonEmpty Chars -> Chars #

stimes :: Integral b => b -> Chars -> Chars #

Methods

mempty :: Chars #

mappend :: Chars -> Chars -> Chars #

mconcat :: [Chars] -> Chars #

Methods

rnf :: Chars -> () #

Methods

toString :: Chars -> String Source #

fromString :: String -> Chars Source #

lines :: ListLike full Chars => Chars -> full Source #

words :: ListLike full Chars => Chars -> full Source #

unlines :: ListLike full Chars => full -> Chars Source #

unwords :: ListLike full Chars => full -> Chars Source #

Methods

foldl :: (a -> Char -> a) -> a -> Chars -> a Source #

foldl' :: (a -> Char -> a) -> a -> Chars -> a Source #

foldl1 :: (Char -> Char -> Char) -> Chars -> Char Source #

foldr :: (Char -> b -> b) -> b -> Chars -> b Source #

foldr' :: (Char -> b -> b) -> b -> Chars -> b Source #

foldr1 :: (Char -> Char -> Char) -> Chars -> Char Source #

Methods

empty :: Chars Source #

singleton :: Char -> Chars Source #

cons :: Char -> Chars -> Chars Source #

snoc :: Chars -> Char -> Chars Source #

append :: Chars -> Chars -> Chars Source #

head :: Chars -> Char Source #

uncons :: Chars -> Maybe (Char, Chars) Source #

last :: Chars -> Char Source #

tail :: Chars -> Chars Source #

init :: Chars -> Chars Source #

null :: Chars -> Bool Source #

length :: Chars -> Int Source #

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

rigidMap :: (Char -> Char) -> Chars -> Chars Source #

reverse :: Chars -> Chars Source #

intersperse :: Char -> Chars -> Chars Source #

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

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

rigidConcatMap :: (Char -> Chars) -> Chars -> Chars Source #

any :: (Char -> Bool) -> Chars -> Bool Source #

all :: (Char -> Bool) -> Chars -> Bool Source #

maximum :: Chars -> Char Source #

minimum :: Chars -> Char Source #

replicate :: Int -> Char -> Chars Source #

take :: Int -> Chars -> Chars Source #

drop :: Int -> Chars -> Chars Source #

splitAt :: Int -> Chars -> (Chars, Chars) Source #

takeWhile :: (Char -> Bool) -> Chars -> Chars Source #

dropWhile :: (Char -> Bool) -> Chars -> Chars Source #

dropWhileEnd :: (Char -> Bool) -> Chars -> Chars Source #

span :: (Char -> Bool) -> Chars -> (Chars, Chars) Source #

break :: (Char -> Bool) -> Chars -> (Chars, Chars) Source #

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

inits :: ListLike full' Chars => Chars -> full' Source #

tails :: ListLike full' Chars => Chars -> full' Source #

isPrefixOf :: Chars -> Chars -> Bool Source #

isSuffixOf :: Chars -> Chars -> Bool Source #

isInfixOf :: Chars -> Chars -> Bool Source #

stripPrefix :: Chars -> Chars -> Maybe Chars Source #

stripSuffix :: Chars -> Chars -> Maybe Chars Source #

elem :: Char -> Chars -> Bool Source #

notElem :: Char -> Chars -> Bool Source #

find :: (Char -> Bool) -> Chars -> Maybe Char Source #

filter :: (Char -> Bool) -> Chars -> Chars Source #

partition :: (Char -> Bool) -> Chars -> (Chars, Chars) Source #

index :: Chars -> Int -> Char Source #

elemIndex :: Char -> Chars -> Maybe Int Source #

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

findIndex :: (Char -> Bool) -> Chars -> Maybe Int Source #

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

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

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

rigidMapM :: Monad m => (Char -> m Char) -> Chars -> m Chars Source #

nub :: Chars -> Chars Source #

delete :: Char -> Chars -> Chars Source #

deleteFirsts :: Chars -> Chars -> Chars Source #

union :: Chars -> Chars -> Chars Source #

intersect :: Chars -> Chars -> Chars Source #

sort :: Chars -> Chars Source #

insert :: Char -> Chars -> Chars Source #

toList :: Chars -> [Char] Source #

fromList :: [Char] -> Chars Source #

fromListLike :: ListLike full' Char => Chars -> full' Source #

nubBy :: (Char -> Char -> Bool) -> Chars -> Chars Source #

deleteBy :: (Char -> Char -> Bool) -> Char -> Chars -> Chars Source #

deleteFirstsBy :: (Char -> Char -> Bool) -> Chars -> Chars -> Chars Source #

unionBy :: (Char -> Char -> Bool) -> Chars -> Chars -> Chars Source #

intersectBy :: (Char -> Char -> Bool) -> Chars -> Chars -> Chars Source #

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

sortBy :: (Char -> Char -> Ordering) -> Chars -> Chars Source #

insertBy :: (Char -> Char -> Ordering) -> Char -> Chars -> Chars Source #

genericLength :: Num a => Chars -> a Source #

genericTake :: Integral a => a -> Chars -> Chars Source #

genericDrop :: Integral a => a -> Chars -> Chars Source #

genericSplitAt :: Integral a => a -> Chars -> (Chars, Chars) Source #

genericReplicate :: Integral a => a -> Char -> Chars Source #

Methods

hGetLine :: Handle -> IO Chars Source #

hGetContents :: Handle -> IO Chars Source #

hGet :: Handle -> Int -> IO Chars Source #

hGetNonBlocking :: Handle -> Int -> IO Chars Source #

hPutStr :: Handle -> Chars -> IO () Source #

hPutStrLn :: Handle -> Chars -> IO () Source #

getLine :: IO Chars Source #

getContents :: IO Chars Source #

putStr :: Chars -> IO () Source #

putStrLn :: Chars -> IO () Source #

interact :: (Chars -> Chars) -> IO () Source #

readFile :: FilePath -> IO Chars Source #

writeFile :: FilePath -> Chars -> IO () Source #

appendFile :: FilePath -> Chars -> IO () Source #