Documentation

Methods

readsPrec :: Int -> ReadS Color #

readList :: ReadS [Color] #

readPrec :: ReadPrec Color #

readListPrec :: ReadPrec [Color] #

Methods

showsPrec :: Int -> Color -> ShowS #

show :: Color -> String #

showList :: [Color] -> ShowS #

Methods

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

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

Methods

compare :: Color -> Color -> Ordering #

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

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

(>) :: Color -> Color -> Bool #

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

max :: Color -> Color -> Color #

min :: Color -> Color -> Color #

Methods

fold :: Monoid m => AnnotatedText m -> m #

foldMap :: Monoid m => (a -> m) -> AnnotatedText a -> m #

foldMap' :: Monoid m => (a -> m) -> AnnotatedText a -> m #

foldr :: (a -> b -> b) -> b -> AnnotatedText a -> b #

foldr' :: (a -> b -> b) -> b -> AnnotatedText a -> b #

foldl :: (b -> a -> b) -> b -> AnnotatedText a -> b #

foldl' :: (b -> a -> b) -> b -> AnnotatedText a -> b #

foldr1 :: (a -> a -> a) -> AnnotatedText a -> a #

foldl1 :: (a -> a -> a) -> AnnotatedText a -> a #

toList :: AnnotatedText a -> [a] #

null :: AnnotatedText a -> Bool #

length :: AnnotatedText a -> Int #

elem :: Eq a => a -> AnnotatedText a -> Bool #

maximum :: Ord a => AnnotatedText a -> a #

minimum :: Ord a => AnnotatedText a -> a #

sum :: Num a => AnnotatedText a -> a #

product :: Num a => AnnotatedText a -> a #

Methods

fmap :: (a -> b) -> AnnotatedText a -> AnnotatedText b #

(<$) :: a -> AnnotatedText b -> AnnotatedText a #

Methods

fromString :: String -> AnnotatedText a #

Methods

mempty :: AnnotatedText a #

mappend :: AnnotatedText a -> AnnotatedText a -> AnnotatedText a #

mconcat :: [AnnotatedText a] -> AnnotatedText a #

Methods

(<>) :: AnnotatedText a -> AnnotatedText a -> AnnotatedText a #

sconcat :: NonEmpty (AnnotatedText a) -> AnnotatedText a #

stimes :: Integral b => b -> AnnotatedText a -> AnnotatedText a #

Methods

from :: AnnotatedText a -> Rep (AnnotatedText a) x #

to :: Rep (AnnotatedText a) x -> AnnotatedText a #

Methods

fromList :: [Item (AnnotatedText a)] -> AnnotatedText a #

fromListN :: Int -> [Item (AnnotatedText a)] -> AnnotatedText a #

toList :: AnnotatedText a -> [Item (AnnotatedText a)] #

Methods

showsPrec :: Int -> AnnotatedText a -> ShowS #

show :: AnnotatedText a -> String #

showList :: [AnnotatedText a] -> ShowS #

Methods

(==) :: AnnotatedText a -> AnnotatedText a -> Bool #

(/=) :: AnnotatedText a -> AnnotatedText a -> Bool #

Methods

empty :: AnnotatedText a #

singleton :: Char -> AnnotatedText a #

cons :: Char -> AnnotatedText a -> AnnotatedText a #

snoc :: AnnotatedText a -> Char -> AnnotatedText a #

append :: AnnotatedText a -> AnnotatedText a -> AnnotatedText a #

head :: AnnotatedText a -> Char #

uncons :: AnnotatedText a -> Maybe (Char, AnnotatedText a) #

last :: AnnotatedText a -> Char #

tail :: AnnotatedText a -> AnnotatedText a #

init :: AnnotatedText a -> AnnotatedText a #

null :: AnnotatedText a -> Bool #

length :: AnnotatedText a -> Int #

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

rigidMap :: (Char -> Char) -> AnnotatedText a -> AnnotatedText a #

reverse :: AnnotatedText a -> AnnotatedText a #

intersperse :: Char -> AnnotatedText a -> AnnotatedText a #

concat :: ListLike full' (AnnotatedText a) => full' -> AnnotatedText a #

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

rigidConcatMap :: (Char -> AnnotatedText a) -> AnnotatedText a -> AnnotatedText a #

any :: (Char -> Bool) -> AnnotatedText a -> Bool #

all :: (Char -> Bool) -> AnnotatedText a -> Bool #

maximum :: AnnotatedText a -> Char #

minimum :: AnnotatedText a -> Char #

replicate :: Int -> Char -> AnnotatedText a #

take :: Int -> AnnotatedText a -> AnnotatedText a #

drop :: Int -> AnnotatedText a -> AnnotatedText a #

splitAt :: Int -> AnnotatedText a -> (AnnotatedText a, AnnotatedText a) #

takeWhile :: (Char -> Bool) -> AnnotatedText a -> AnnotatedText a #

dropWhile :: (Char -> Bool) -> AnnotatedText a -> AnnotatedText a #

dropWhileEnd :: (Char -> Bool) -> AnnotatedText a -> AnnotatedText a #

span :: (Char -> Bool) -> AnnotatedText a -> (AnnotatedText a, AnnotatedText a) #

break :: (Char -> Bool) -> AnnotatedText a -> (AnnotatedText a, AnnotatedText a) #

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

inits :: ListLike full' (AnnotatedText a) => AnnotatedText a -> full' #

tails :: ListLike full' (AnnotatedText a) => AnnotatedText a -> full' #

isPrefixOf :: AnnotatedText a -> AnnotatedText a -> Bool #

isSuffixOf :: AnnotatedText a -> AnnotatedText a -> Bool #

isInfixOf :: AnnotatedText a -> AnnotatedText a -> Bool #

stripPrefix :: AnnotatedText a -> AnnotatedText a -> Maybe (AnnotatedText a) #

stripSuffix :: AnnotatedText a -> AnnotatedText a -> Maybe (AnnotatedText a) #

elem :: Char -> AnnotatedText a -> Bool #

notElem :: Char -> AnnotatedText a -> Bool #

find :: (Char -> Bool) -> AnnotatedText a -> Maybe Char #

filter :: (Char -> Bool) -> AnnotatedText a -> AnnotatedText a #

partition :: (Char -> Bool) -> AnnotatedText a -> (AnnotatedText a, AnnotatedText a) #

index :: AnnotatedText a -> Int -> Char #

elemIndex :: Char -> AnnotatedText a -> Maybe Int #

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

findIndex :: (Char -> Bool) -> AnnotatedText a -> Maybe Int #

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

sequence :: (Applicative m, ListLike fullinp (m Char)) => fullinp -> m (AnnotatedText a) #

mapM :: (Applicative m, ListLike full' item') => (Char -> m item') -> AnnotatedText a -> m full' #

rigidMapM :: Monad m => (Char -> m Char) -> AnnotatedText a -> m (AnnotatedText a) #

nub :: AnnotatedText a -> AnnotatedText a #

delete :: Char -> AnnotatedText a -> AnnotatedText a #

deleteFirsts :: AnnotatedText a -> AnnotatedText a -> AnnotatedText a #

union :: AnnotatedText a -> AnnotatedText a -> AnnotatedText a #

intersect :: AnnotatedText a -> AnnotatedText a -> AnnotatedText a #

sort :: AnnotatedText a -> AnnotatedText a #

insert :: Char -> AnnotatedText a -> AnnotatedText a #

toList' :: AnnotatedText a -> [Char] #

fromList' :: [Char] -> AnnotatedText a #

fromListLike :: ListLike full' Char => AnnotatedText a -> full' #

nubBy :: (Char -> Char -> Bool) -> AnnotatedText a -> AnnotatedText a #

deleteBy :: (Char -> Char -> Bool) -> Char -> AnnotatedText a -> AnnotatedText a #

deleteFirstsBy :: (Char -> Char -> Bool) -> AnnotatedText a -> AnnotatedText a -> AnnotatedText a #

unionBy :: (Char -> Char -> Bool) -> AnnotatedText a -> AnnotatedText a -> AnnotatedText a #

intersectBy :: (Char -> Char -> Bool) -> AnnotatedText a -> AnnotatedText a -> AnnotatedText a #

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

sortBy :: (Char -> Char -> Ordering) -> AnnotatedText a -> AnnotatedText a #

insertBy :: (Char -> Char -> Ordering) -> Char -> AnnotatedText a -> AnnotatedText a #

genericLength :: Num a0 => AnnotatedText a -> a0 #

genericTake :: Integral a0 => a0 -> AnnotatedText a -> AnnotatedText a #

genericDrop :: Integral a0 => a0 -> AnnotatedText a -> AnnotatedText a #

genericSplitAt :: Integral a0 => a0 -> AnnotatedText a -> (AnnotatedText a, AnnotatedText a) #

genericReplicate :: Integral a0 => a0 -> Char -> AnnotatedText a #

Methods

foldl :: (a0 -> Char -> a0) -> a0 -> AnnotatedText a -> a0 #

foldl' :: (a0 -> Char -> a0) -> a0 -> AnnotatedText a -> a0 #

foldl1 :: (Char -> Char -> Char) -> AnnotatedText a -> Char #

foldr :: (Char -> b -> b) -> b -> AnnotatedText a -> b #

foldr' :: (Char -> b -> b) -> b -> AnnotatedText a -> b #

foldr1 :: (Char -> Char -> Char) -> AnnotatedText a -> Char #

Methods

fold :: Monoid m => Segment m -> m #

foldMap :: Monoid m => (a -> m) -> Segment a -> m #

foldMap' :: Monoid m => (a -> m) -> Segment a -> m #

foldr :: (a -> b -> b) -> b -> Segment a -> b #

foldr' :: (a -> b -> b) -> b -> Segment a -> b #

foldl :: (b -> a -> b) -> b -> Segment a -> b #

foldl' :: (b -> a -> b) -> b -> Segment a -> b #

foldr1 :: (a -> a -> a) -> Segment a -> a #

foldl1 :: (a -> a -> a) -> Segment a -> a #

toList :: Segment a -> [a] #

null :: Segment a -> Bool #

length :: Segment a -> Int #

elem :: Eq a => a -> Segment a -> Bool #

maximum :: Ord a => Segment a -> a #

minimum :: Ord a => Segment a -> a #

sum :: Num a => Segment a -> a #

product :: Num a => Segment a -> a #

Methods

fmap :: (a -> b) -> Segment a -> Segment b #

(<$) :: a -> Segment b -> Segment a #

Methods

from :: Segment a -> Rep (Segment a) x #

to :: Rep (Segment a) x -> Segment a #

Methods

showsPrec :: Int -> Segment a -> ShowS #

show :: Segment a -> String #

showList :: [Segment a] -> ShowS #

Methods

(==) :: Segment a -> Segment a -> Bool #

(/=) :: Segment a -> Segment a -> Bool #