Hoogle Search

Within LTS Haskell 24.4 (ghc-9.10.2)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()

    base Prelude

    Evaluate each monadic action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequence. sequence_ is just like sequenceA_, but specialised to monadic actions.

  2. isSubsequenceOf :: Eq a => [a] -> [a] -> Bool

    base Data.List

    The isSubsequenceOf function takes two lists and returns True if all the elements of the first list occur, in order, in the second. The elements do not have to occur consecutively. isSubsequenceOf x y is equivalent to x `elem` (subsequences y). Note: isSubsequenceOf is often used in infix form.

    Examples

    >>> "GHC" `isSubsequenceOf` "The Glorious Haskell Compiler"
True

    >>> ['a','d'..'z'] `isSubsequenceOf` ['a'..'z']
True

    >>> [1..10] `isSubsequenceOf` [10,9..0]
False
    For the result to be True, the first list must be finite; for the result to be False, the second list must be finite: 
    >>> [0,2..10] `isSubsequenceOf` [0..]
True

    >>> [0..] `isSubsequenceOf` [0,2..10]
False

    >>> [0,2..] `isSubsequenceOf` [0..]
* Hangs forever*

  3. subsequences :: [a] -> [[a]]

    base Data.List

    The subsequences function returns the list of all subsequences of the argument.

    Laziness

    subsequences does not look ahead unless it must: 
    >>> take 1 (subsequences undefined)
[[]]

>>> take 2 (subsequences ('a' : undefined))
["","a"]

    Examples

    >>> subsequences "abc"
["","a","b","ab","c","ac","bc","abc"]
    This function is productive on infinite inputs: 
    >>> take 8 $ subsequences ['a'..]
["","a","b","ab","c","ac","bc","abc"]

  4. sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)

    base Control.Monad

    Evaluate each monadic action in the structure from left to right, and collect the results. For a version that ignores the results see sequence_.

    Examples

    Basic usage: The first two examples are instances where the input and and output of sequence are isomorphic. 
    >>> sequence $ Right [1,2,3,4]
[Right 1,Right 2,Right 3,Right 4]

    >>> sequence $ [Right 1,Right 2,Right 3,Right 4]
Right [1,2,3,4]
    The following examples demonstrate short circuit behavior for sequence. 
    >>> sequence $ Left [1,2,3,4]
Left [1,2,3,4]

    >>> sequence $ [Left 0, Right 1,Right 2,Right 3,Right 4]
Left 0

  5. sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()

    base Control.Monad

    Evaluate each monadic action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequence. sequence_ is just like sequenceA_, but specialised to monadic actions.

  6. bisequenceA_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()

    base Data.Bifoldable

    Alias for bisequence_.

  7. bisequence_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()

    base Data.Bifoldable

    Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results, see bisequence.

    Examples

    Basic usage: 
    >>> bisequence_ (print "Hello", print "World")
"Hello"
"World"

    >>> bisequence_ (Left (print "Hello"))
"Hello"

    >>> bisequence_ (Right (print "World"))
"World"

  8. bisequence :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b)

    base Data.Bitraversable

    Sequences all the actions in a structure, building a new structure with the same shape using the results of the actions. For a version that ignores the results, see bisequence_. 

    bisequence ≡ bitraverse id id

    Examples

    Basic usage: 
    >>> bisequence (Just 4, Nothing)
Nothing

    >>> bisequence (Just 4, Just 5)
Just (4,5)

    >>> bisequence ([1, 2, 3], [4, 5])
[(1,4),(1,5),(2,4),(2,5),(3,4),(3,5)]

  9. bisequenceA :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b)

    base Data.Bitraversable

    Alias for bisequence.

  10. sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()

    base Data.Foldable

    Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequenceA. sequenceA_ is just like sequence_, but generalised to Applicative actions.

    Examples

    Basic usage: 
    >>> sequenceA_ [print "Hello", print "world", print "!"]
"Hello"
"world"
"!"

Page 131 of many | Previous | Next