[[a]] -> [a] -filepath +base

concat :: [[a]] -> [a]
base Prelude, base Data.List
Concatenate a list of lists.
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.
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.
unlines :: [String] -> String
base Prelude, base Data.List, base Data.String
unlines is an inverse operation to lines. It joins lines, after appending a terminating newline to each.
unwords :: [String] -> String
base Prelude, base Data.List, base Data.String
unwords is an inverse operation to words. It joins words with separating spaces.
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]

Show more results