Documentation

(!!) :: [a] -> Int -> a #

(++) :: [a] -> [a] -> [a] infixr 5 #

(\\) :: Eq a => [a] -> [a] -> [a] infix 5 #

all :: (a -> Bool) -> [a] -> Bool #

and :: [Bool] -> Bool #

any :: (a -> Bool) -> [a] -> Bool #

break :: (a -> Bool) -> [a] -> ([a], [a]) #

concat :: [[a]] -> [a] #

concatMap :: (a -> [b]) -> [a] -> [b] #

cycle :: [a] -> [a] #

delete :: Eq a => a -> [a] -> [a] #

deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a] #

deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] #

drop :: Int -> [a] -> [a] #

dropWhile :: (a -> Bool) -> [a] -> [a] #

elem :: Eq a => a -> [a] -> Bool #

elemIndex :: Eq a => a -> [a] -> Maybe Int #

elemIndices :: Eq a => a -> [a] -> [Int] #

filter :: (a -> Bool) -> [a] -> [a] #

find :: (a -> Bool) -> [a] -> Maybe a #

findIndex :: (a -> Bool) -> [a] -> Maybe Int #

findIndices :: (a -> Bool) -> [a] -> [Int] #

foldl :: (a -> b -> a) -> a -> [b] -> a #

foldl' :: (a -> b -> a) -> a -> [b] -> a #

foldl1 :: (a -> a -> a) -> [a] -> a #

foldl1' :: (a -> a -> a) -> [a] -> a #

foldr :: (a -> b -> b) -> b -> [a] -> b #

foldr1 :: (a -> a -> a) -> [a] -> a #

genericDrop :: Integral i => i -> [a] -> [a] #

genericIndex :: Integral a => [b] -> a -> b #

genericLength :: Num i => [b] -> i #

genericReplicate :: Integral i => i -> a -> [a] #

genericSplitAt :: Integral i => i -> [b] -> ([b], [b]) #

genericTake :: Integral i => i -> [a] -> [a] #

group :: Eq a => [a] -> [[a]] #

groupBy :: (a -> a -> Bool) -> [a] -> [[a]] #

head :: [a] -> a #

init :: [a] -> [a] #

inits :: [a] -> [[a]] #

insert :: Ord a => a -> [a] -> [a] #

insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a] #

intercalate :: [a] -> [[a]] -> [a] #

intersect :: Eq a => [a] -> [a] -> [a] #

intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] #

intersperse :: a -> [a] -> [a] #

isInfixOf :: Eq a => [a] -> [a] -> Bool #

isPrefixOf :: Eq a => [a] -> [a] -> Bool #

isSuffixOf :: Eq a => [a] -> [a] -> Bool #

iterate :: (a -> a) -> a -> [a] #

last :: [a] -> a #

length :: [a] -> Int #

lines :: String -> [String] #

lookup :: Eq a => a -> [(a, b)] -> Maybe b #

map :: (a -> b) -> [a] -> [b] #

mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) #

mapAccumR :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) #

maximum :: Ord a => [a] -> a #

maximumBy :: (a -> a -> Ordering) -> [a] -> a #

minimum :: Ord a => [a] -> a #

minimumBy :: (a -> a -> Ordering) -> [a] -> a #

notElem :: Eq a => a -> [a] -> Bool #

nub :: Eq a => [a] -> [a] #

nubBy :: (a -> a -> Bool) -> [a] -> [a] #

null :: [a] -> Bool #

or :: [Bool] -> Bool #

partition :: (a -> Bool) -> [a] -> ([a], [a]) #

permutations :: [a] -> [[a]] #

product :: Num a => [a] -> a #

repeat :: a -> [a] #

replicate :: Int -> a -> [a] #

reverse :: [a] -> [a] #

scanl :: (a -> b -> a) -> a -> [b] -> [a] #

scanl1 :: (a -> a -> a) -> [a] -> [a] #

scanr :: (a -> b -> b) -> b -> [a] -> [b] #

scanr1 :: (a -> a -> a) -> [a] -> [a] #

sort :: Ord a => [a] -> [a] #

sortBy :: (a -> a -> Ordering) -> [a] -> [a] #

span :: (a -> Bool) -> [a] -> ([a], [a]) #

splitAt :: Int -> [a] -> ([a], [a]) #

stripPrefix :: Eq a => [a] -> [a] -> Maybe [a] #

subsequences :: [a] -> [[a]] #

sum :: Num a => [a] -> a #

tail :: [a] -> [a] #

tails :: [a] -> [[a]] #

take :: Int -> [a] -> [a] #

takeWhile :: (a -> Bool) -> [a] -> [a] #

transpose :: [[a]] -> [[a]] #

unfoldr :: (b -> Maybe (a, b)) -> b -> [a] #

union :: Eq a => [a] -> [a] -> [a] #

unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] #

unlines :: [String] -> String #

unwords :: [String] -> String #

unzip :: [(a, b)] -> ([a], [b]) #

unzip3 :: [(a, b, c)] -> ([a], [b], [c]) #

unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d]) #

unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e]) #

unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f]) #

unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g]) #

words :: String -> [String] #

zip :: [a] -> [b] -> [(a, b)] #

zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] #

zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)] #

zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)] #

zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)] #

zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)] #

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] #

zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] #

zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e] #

zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] #

zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] #

zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h] #