[[a]] -> [[a]]

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 :: [[a]] -> [a]
base Prelude, base Data.List
Concatenate a list of lists.
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"]
subsequences :: [a] -> [[a]]
base Data.List
The subsequences function returns the list of all subsequences of the argument. > subsequences "abc" == ["","a","b","ab","c","ac","bc","abc"]
tails :: [a] -> [[a]]
base Data.List
The tails function returns all final segments of the argument, longest first. For example, > tails "abc" == ["abc", "bc", "c",""]
sequence :: Monad m => [m a] -> m [a]
base Prelude, base Control.Monad
Evaluate each action in the sequence from left to right, and collect the results.
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.
groupWith :: Ord b => (a -> b) -> [a] -> [[a]]
base GHC.Exts
The groupWith function uses the user supplied function which projects an element out of every list element in order to to first sort the input list and then to form groups by equality on these projected elements
groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
base Data.List
The groupBy function is the non-overloaded version of group.
shrinkList :: (a -> [a]) -> [a] -> [[a]]
QuickCheck Test.QuickCheck.Arbitrary
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
base Data.Traversable
concat :: Foldable t => t [a] -> [a]
base Data.Foldable
The concatenation of all the elements of a container of lists.
group :: Eq a => [a] -> [[a]]
base Data.List
The group function takes a list and returns a list of lists such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example, > group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"] It is a special case of groupBy, which allows the programmer to supply their own equality test.
msum :: MonadPlus m => [m a] -> m a
base Control.Monad
This generalizes the list-based concat function.
many :: Alternative f => f a -> f [a]
base Control.Applicative
some :: Alternative f => f a -> f [a]
base Control.Applicative
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.

Show more results