ListLike-4.5.1: Generic support for list-like structures

Safe HaskellNone
LanguageHaskell98

Data.ListLike.DList

Contents

Description

ListLike instances for DList

Orphan instances

StringLike (DList Char) # 

Methods

toString :: DList Char -> String #

fromString :: String -> DList Char #

lines :: ListLike full (DList Char) => DList Char -> full #

words :: ListLike full (DList Char) => DList Char -> full #

unlines :: ListLike full (DList Char) => full -> DList Char #

unwords :: ListLike full (DList Char) => full -> DList Char #

FoldableLL (DList a) a # 

Methods

foldl :: (a -> a -> a) -> a -> DList a -> a #

foldl' :: (a -> a -> a) -> a -> DList a -> a #

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

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

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

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

ListLike (DList a) a # 

Methods

empty :: DList a #

singleton :: a -> DList a #

cons :: a -> DList a -> DList a #

snoc :: DList a -> a -> DList a #

append :: DList a -> DList a -> DList a #

head :: DList a -> a #

uncons :: DList a -> Maybe (a, DList a) #

last :: DList a -> a #

tail :: DList a -> DList a #

init :: DList a -> DList a #

null :: DList a -> Bool #

length :: DList a -> Int #

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

rigidMap :: (a -> a) -> DList a -> DList a #

reverse :: DList a -> DList a #

intersperse :: a -> DList a -> DList a #

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

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

rigidConcatMap :: (a -> DList a) -> DList a -> DList a #

any :: (a -> Bool) -> DList a -> Bool #

all :: (a -> Bool) -> DList a -> Bool #

maximum :: DList a -> a #

minimum :: DList a -> a #

replicate :: Int -> a -> DList a #

take :: Int -> DList a -> DList a #

drop :: Int -> DList a -> DList a #

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

takeWhile :: (a -> Bool) -> DList a -> DList a #

dropWhile :: (a -> Bool) -> DList a -> DList a #

dropWhileEnd :: (a -> Bool) -> DList a -> DList a #

span :: (a -> Bool) -> DList a -> (DList a, DList a) #

break :: (a -> Bool) -> DList a -> (DList a, DList a) #

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

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

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

isPrefixOf :: DList a -> DList a -> Bool #

isSuffixOf :: DList a -> DList a -> Bool #

isInfixOf :: DList a -> DList a -> Bool #

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

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

elem :: a -> DList a -> Bool #

notElem :: a -> DList a -> Bool #

find :: (a -> Bool) -> DList a -> Maybe a #

filter :: (a -> Bool) -> DList a -> DList a #

partition :: (a -> Bool) -> DList a -> (DList a, DList a) #

index :: DList a -> Int -> a #

elemIndex :: a -> DList a -> Maybe Int #

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

findIndex :: (a -> Bool) -> DList a -> Maybe Int #

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

sequence :: (Monad m, ListLike fullinp (m a)) => fullinp -> m (DList a) #

mapM :: (Monad m, ListLike full' item') => (a -> m item') -> DList a -> m full' #

rigidMapM :: Monad m => (a -> m a) -> DList a -> m (DList a) #

nub :: DList a -> DList a #

delete :: a -> DList a -> DList a #

deleteFirsts :: DList a -> DList a -> DList a #

union :: DList a -> DList a -> DList a #

intersect :: DList a -> DList a -> DList a #

sort :: DList a -> DList a #

insert :: a -> DList a -> DList a #

toList :: DList a -> [a] #

fromList :: [a] -> DList a #

fromListLike :: ListLike full' a => DList a -> full' #

nubBy :: (a -> a -> Bool) -> DList a -> DList a #

deleteBy :: (a -> a -> Bool) -> a -> DList a -> DList a #

deleteFirstsBy :: (a -> a -> Bool) -> DList a -> DList a -> DList a #

unionBy :: (a -> a -> Bool) -> DList a -> DList a -> DList a #

intersectBy :: (a -> a -> Bool) -> DList a -> DList a -> DList a #

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

sortBy :: (a -> a -> Ordering) -> DList a -> DList a #

insertBy :: (a -> a -> Ordering) -> a -> DList a -> DList a #

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

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

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

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

genericReplicate :: Integral a => a -> a -> DList a #