Alternative f => [f a] -> f a -fgl -quickcheck

asum :: (Foldable t, Alternative f) => t (f a) -> f a
base Data.Foldable
The sum of a collection of actions, generalizing concat.
msum :: MonadPlus m => [m a] -> m a
base Control.Monad
This generalizes the list-based concat function.
(<|>) :: Alternative f => f a -> f a -> f a
base Control.Applicative
unions :: [IntMap a] -> IntMap a
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
The union of a list of maps. > unions [(fromList [(5, "a"), (3, "b")]), (fromList [(5, "A"), (7, "C")]), (fromList [(5, "A3"), (3, "B3")])] > == fromList [(3, "b"), (5, "a"), (7, "C")] > unions [(fromList [(5, "A3"), (3, "B3")]), (fromList [(5, "A"), (7, "C")]), (fromList [(5, "a"), (3, "b")])] > == fromList [(3, "B3"), (5, "A3"), (7, "C")]
choice :: [ReadP a] -> ReadP a
base Text.ParserCombinators.ReadP
Combines all parsers in the specified list.
choice :: [ReadPrec a] -> ReadPrec a
base Text.ParserCombinators.ReadPrec
Combines all parsers in the specified list.
concat :: [[a]] -> [a]
base Prelude, base Data.List
Concatenate a list of lists.
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
base Data.Foldable
The sum of a collection of actions, generalizing concat.
unionsWith :: (a -> a -> a) -> [IntMap a] -> IntMap a
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
The union of a list of maps, with a combining operation. > unionsWith (++) [(fromList [(5, "a"), (3, "b")]), (fromList [(5, "A"), (7, "C")]), (fromList [(5, "A3"), (3, "B3")])] > == fromList [(3, "bB3"), (5, "aAA3"), (7, "C")]
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.
sequence_ :: Monad m => [m a] -> m ()
base Prelude, base Control.Monad
Evaluate each action in the sequence from left to right, and ignore the results.
unions :: Ord a => [Set a] -> Set a
containers Data.Set
The union of a list of sets: (unions == foldl union empty).
Node :: a -> Forest a -> Tree a
containers Data.Tree
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.
optional :: Alternative f => f a -> f (Maybe a)
base Control.Applicative
One or none.
many :: Alternative f => f a -> f [a]
base Control.Applicative
some :: Alternative f => f a -> f [a]
base Control.Applicative
block :: IO a -> IO a
base Control.Exception.Base, base Control.Exception, base Control.OldException
Note: this function is deprecated, please use mask instead. Applying block to a computation will execute that computation with asynchronous exceptions blocked. That is, any thread which attempts to raise an exception in the current thread with Control.Exception.throwTo will be blocked until asynchronous exceptions are unblocked again. There's no need to worry about re-enabling asynchronous exceptions; that is done automatically on exiting the scope of block. Threads created by Control.Concurrent.forkIO inherit the blocked state from the parent; that is, to start a thread in blocked mode, use block $ forkIO .... This is particularly useful if you need to establish an exception handler in the forked thread before any asynchronous exceptions are received.

Show more results