Hoogle Search

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

equal :: Exp t -> PAtom t

yi-mode-haskell Yi.Syntax.Haskell

No documentation available.
seq :: a -> b -> b

base Prelude

The value of seq a b is bottom if a is bottom, and otherwise equal to b. In other words, it evaluates the first argument a to weak head normal form (WHNF). seq is usually introduced to improve performance by avoiding unneeded laziness. A note on evaluation order: the expression seq a b does not guarantee that a will be evaluated before b. The only guarantee given by seq is that the both a and b will be evaluated before seq returns a value. In particular, this means that b may be evaluated before a. If you need to guarantee a specific order of evaluation, you must use the function pseq from the "parallel" package.
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)

base Prelude

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
```
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)

base Prelude

Evaluate each action in the structure from left to right, and collect the results. For a version that ignores the results see sequenceA_.
Examples
Basic usage: For the first two examples we show sequenceA fully evaluating a a structure and collecting the results.
```
>>> sequenceA [Just 1, Just 2, Just 3]
Just [1,2,3]
```
```
>>> sequenceA [Right 1, Right 2, Right 3]
Right [1,2,3]
```
The next two example show Nothing and Just will short circuit the resulting structure if present in the input. For more context, check the Traversable instances for Either and Maybe.
```
>>> sequenceA [Just 1, Just 2, Just 3, Nothing]
Nothing
```
```
>>> sequenceA [Right 1, Right 2, Right 3, Left 4]
Left 4
```
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.
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*
```

yi-mode-haskell	Yi.Syntax.Haskell

base	Prelude

base	Prelude

base	Prelude

base	Prelude

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"]

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
```
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.
bisequenceA_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()

base Data.Bifoldable

Alias for bisequence_.

base	Control.Monad

base	Control.Monad

base	Data.Bifoldable

Page 133 of many | Previous | Next