[[Int]] -> [Int]

concat :: [[a]] -> [a]
base Prelude, base Data.List
Concatenate a list of lists.
getPath :: Node -> RTree -> Path
fgl Data.Graph.Inductive.Internal.RootPath
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.
nmergeIO :: [[a]] -> IO [a]
base Control.Concurrent
transpose :: [[a]] -> [[a]]
base Data.List
The transpose function transposes the rows and columns of its argument. For example, > transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]]
concat :: Foldable t => t [a] -> [a]
base Data.Foldable
The concatenation of all the elements of a container of lists.
msum :: MonadPlus m => [m a] -> m a
base Control.Monad
This generalizes the list-based concat function.
bfsn :: Graph gr => [Node] -> gr a b -> [Node]
fgl Data.Graph.Inductive.Query.BFS
dfs :: Graph gr => [Node] -> gr a b -> [Node]
fgl Data.Graph.Inductive.Query.DFS
rdfs :: Graph gr => [Node] -> gr a b -> [Node]
fgl Data.Graph.Inductive.Query.DFS
udfs :: Graph gr => [Node] -> gr a b -> [Node]
fgl Data.Graph.Inductive.Query.DFS
cycle :: [a] -> [a]
base Prelude, base Data.List
cycle ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists.
init :: [a] -> [a]
base Prelude, base Data.List
Return all the elements of a list except the last one. The list must be non-empty.
reverse :: [a] -> [a]
base Prelude, base Data.List
reverse xs returns the elements of xs in reverse order. xs must be finite.
tail :: [a] -> [a]
base Prelude, base Data.List
Extract the elements after the head of a list, which must be non-empty.
join :: Monad m => m (m a) -> m a
base Control.Monad
The join function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.
augment :: (forall b. (a -> b -> b) -> b -> b) -> [a] -> [a]
base GHC.Exts
A list producer that can be fused with foldr. This function is merely > augment g xs = g (:) xs but GHC's simplifier will transform an expression of the form foldr k z (augment g xs), which may arise after inlining, to g k (foldr k z xs), which avoids producing an intermediate list.
sortWith :: Ord b => (a -> b) -> [a] -> [a]
base GHC.Exts
The sortWith function sorts a list of elements using the user supplied function to project something out of each element
scanl1 :: (a -> a -> a) -> [a] -> [a]
base Prelude, base Data.List
scanl1 is a variant of scanl that has no starting value argument: > scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
scanr1 :: (a -> a -> a) -> [a] -> [a]
base Prelude, base Data.List
scanr1 is a variant of scanr that has no starting value argument.
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
base Data.List
The sortBy function is the non-overloaded version of sort.
nubBy :: (a -> a -> Bool) -> [a] -> [a]
base Data.List
The nubBy function behaves just like nub, except it uses a user-supplied equality predicate instead of the overloaded == function.
dropWhile :: (a -> Bool) -> [a] -> [a]
base Prelude, base Data.List
dropWhile p xs returns the suffix remaining after takeWhile p xs: > dropWhile (< 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3] > dropWhile (< 9) [1,2,3] == [] > dropWhile (< 0) [1,2,3] == [1,2,3]
filter :: (a -> Bool) -> [a] -> [a]
base Prelude, base Data.List
filter, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e., > filter p xs = [ x | x <- xs, p x]
takeWhile :: (a -> Bool) -> [a] -> [a]
base Prelude, base Data.List
takeWhile, applied to a predicate p and a list xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p: > takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2] > takeWhile (< 9) [1,2,3] == [1,2,3] > takeWhile (< 0) [1,2,3] == []
findIndices :: (a -> Bool) -> [a] -> [Int]
base Data.List
The findIndices function extends findIndex, by returning the indices of all elements satisfying the predicate, in ascending order.
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.
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"
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.
(++) :: [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.
asum :: (Foldable t, Alternative f) => t (f a) -> f a
base Data.Foldable
The sum of a collection of actions, generalizing concat.
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
base Data.Foldable
The sum of a collection of actions, generalizing concat.
dfsM :: GraphM m gr => [Node] -> m (gr a b) -> m [Node]
fgl Data.Graph.Inductive.Query.Monad
depth-first search yielding number of nodes
sort :: Ord a => [a] -> [a]
base Data.List
The sort function implements a stable sorting algorithm. It is a special case of sortBy, which allows the programmer to supply their own comparison function.
heapsort :: Ord a => [a] -> [a]
fgl Data.Graph.Inductive.Internal.Heap
nub :: Eq a => [a] -> [a]
base Data.List
O(n^2). The nub function removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. (The name nub means `essence'.) It is a special case of nubBy, which allows the programmer to supply their own equality test.
inits :: [a] -> [[a]]
base Data.List
The inits function returns all initial segments of the argument, shortest first. For example, > inits "abc" == ["","a","ab","abc"]
permutations :: [a] -> [[a]]
base Data.List
The permutations function returns the list of all permutations of the argument. > permutations "abc" == ["abc","bac","cba","bca","cab","acb"]

Show more results