Int -> [a] -> [[a]] -text

drop :: Int -> [a] -> [a]
base Prelude, base Data.List
drop n xs returns the suffix of xs after the first n elements, or [] if n > length xs: > drop 6 "Hello World!" == "World!" > drop 3 [1,2,3,4,5] == [4,5] > drop 3 [1,2] == [] > drop 3 [] == [] > drop (-1) [1,2] == [1,2] > drop 0 [1,2] == [1,2] It is an instance of the more general Data.List.genericDrop, in which n may be of any integral type.
take :: Int -> [a] -> [a]
base Prelude, base Data.List
take n, applied to a list xs, returns the prefix of xs of length n, or xs itself if n > length xs: > take 5 "Hello World!" == "Hello" > take 3 [1,2,3,4,5] == [1,2,3] > take 3 [1,2] == [1,2] > take 3 [] == [] > take (-1) [1,2] == [] > take 0 [1,2] == [] It is an instance of the more general Data.List.genericTake, in which n may be of any integral type.
replicateM :: Monad m => Int -> m a -> m [a]
base Control.Monad
replicateM n act performs the action n times, gathering the results.
intersperse :: a -> [a] -> [a]
base Data.List
The intersperse function takes an element and a list and `intersperses' that element between the elements of the list. For example, > intersperse ',' "abcde" == "a,b,c,d,e"
replicate :: Int -> a -> [a]
base Prelude, base Data.List
replicate n x is a list of length n with x the value of every element. It is an instance of the more general Data.List.genericReplicate, in which n may be of any integral type.
number :: Int -> String -> String
QuickCheck Test.QuickCheck.Text
short :: Int -> String -> String
QuickCheck Test.QuickCheck.Text
insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
base Data.List
The non-overloaded version of insert.
deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
base Data.List
The deleteBy function behaves like delete, but takes a user-supplied equality predicate.
genericDrop :: Integral i => i -> [a] -> [a]
base Data.List
The genericDrop function is an overloaded version of drop, which accepts any Integral value as the number of elements to drop.
genericTake :: Integral i => i -> [a] -> [a]
base Data.List
The genericTake function is an overloaded version of take, which accepts any Integral value as the number of elements to take.
(++) :: [a] -> [a] -> [a]
base Prelude, base Data.List
Append two lists, i.e., > [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn] > [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...] If the first list is not finite, the result is the first list.
deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
base Data.List
The deleteFirstsBy function takes a predicate and two lists and returns the first list with the first occurrence of each element of the second list removed.
intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
base Data.List
The intersectBy function is the non-overloaded version of intersect.
unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
base Data.List
The unionBy function is the non-overloaded version of union.
scanl :: (a -> b -> a) -> a -> [b] -> [a]
base Prelude, base Data.List
scanl is similar to foldl, but returns a list of successive reduced values from the left: > scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] Note that > last (scanl f z xs) == foldl f z xs.
insert :: Ord a => a -> [a] -> [a]
base Data.List
The insert function takes an element and a list and inserts the element into the list at the last position or equal to the next element. In particular, if the list is sorted before the call, the result will also be sorted. It is a special case of insertBy, which allows the programmer to supply their own comparison function.
delete :: Eq a => a -> [a] -> [a]
base Data.List
delete x removes the first occurrence of x from its list argument. For example, > delete 'a' "banana" == "bnana" It is a special case of deleteBy, which allows the programmer to supply their own equality test.
scanr :: (a -> b -> b) -> b -> [a] -> [b]
base Prelude, base Data.List
scanr is the right-to-left dual of scanl. Note that > head (scanr f z xs) == foldr f z xs.
intercalate :: [a] -> [[a]] -> [a]
base Data.List
intercalate xs xss is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.
(<|>) :: Alternative f => f a -> f a -> f a
base Control.Applicative
mplus :: MonadPlus m => m a -> m a -> m a
base Control.Monad
(*>) :: Applicative f => f a -> f b -> f b
base Control.Applicative
getPath :: Node -> RTree -> Path
fgl Data.Graph.Inductive.Internal.RootPath
genericReplicate :: Integral i => i -> a -> [a]
base Data.List
The genericReplicate function is an overloaded version of replicate, which accepts any Integral value as the number of repetitions to make.
(<*) :: Applicative f => f a -> f b -> f a
base Control.Applicative
replicateM_ :: Monad m => Int -> m a -> m ()
base Control.Monad
Like replicateM, but discards the result.
replace :: Eq a => a -> a -> [a] -> [a]
cgi Network.CGI.Protocol
Replaces all instances of a value in a list by another value.
renderHtmlWithLanguage :: HTML html => String -> html -> String
xhtml Text.XHtml.Strict
Outputs indented XHTML. Because space matters in HTML, the output is quite messy.
sp :: (Graph gr, Real b) => Node -> Node -> gr a b -> Path
fgl Data.Graph.Inductive.Query.SP
esp :: Graph gr => Node -> Node -> gr a b -> Path
fgl Data.Graph.Inductive.Query.BFS
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
base Prelude, base Data.List
zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function. For example, zipWith (+) is applied to two lists to produce the list of corresponding sums.
(\\) :: Eq a => [a] -> [a] -> [a]
base Data.List
The \\ function is list difference ((non-associative). In the result of xs \\ ys, the first occurrence of each element of ys in turn (if any) has been removed from xs. Thus > (xs ++ ys) \\ xs == ys. It is a special case of deleteFirstsBy, which allows the programmer to supply their own equality test.
intersect :: Eq a => [a] -> [a] -> [a]
base Data.List
The intersect function takes the list intersection of two lists. For example, > [1,2,3,4] `intersect` [2,4,6,8] == [2,4] If the first list contains duplicates, so will the result. > [1,2,2,3,4] `intersect` [6,4,4,2] == [2,2,4] It is a special case of intersectBy, which allows the programmer to supply their own equality test.
union :: Eq a => [a] -> [a] -> [a]
base Data.List
The union function returns the list union of the two lists. For example, > "dog" `union` "cow" == "dogcw" Duplicates, and elements of the first list, are removed from the the second list, but if the first list contains duplicates, so will the result. It is a special case of unionBy, which allows the programmer to supply their own equality test.
qRecover :: Quasi m => m a -> m a -> m a
template-haskell Language.Haskell.TH.Syntax
(>>) :: Monad m => m a -> m b -> m b
base Prelude, base Control.Monad, base Control.Monad.Instances
msPath :: Real b => LRTree b -> Node -> Node -> Path
fgl Data.Graph.Inductive.Query.MST
enumFromThen :: Enum a => a -> a -> [a]
base Prelude
enumFromTo :: Enum a => a -> a -> [a]
base Prelude

Show more results