Hoogle Search

Within Stackage Nightly 2025-08-12 (ghc-9.12.2)

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

type family (ma :: monad a) >>= (f :: a ~> monad b) :: monad b

type-spec Test.TypeSpec.Internal.Apply

Bind to actions.
(>>=) :: Monad m => m a -> (a -> m b) -> m b

basic-prelude BasicPrelude

Sequentially compose two actions, passing any value produced by the first as an argument to the second. 'as >>= bs' can be understood as the do expression
```
do a <- as
bs a
```
An alternative name for this function is 'bind', but some people may refer to it as 'flatMap', which results from it being equivalent to
```
\x f -> join (fmap f x) :: Monad m => m a -> (a -> m b) -> m b
```
which can be seen as mapping a value with Monad m => m a -> m (m b) and then 'flattening' m (m b) to m b using join.
(>>=) :: Monad m => m a -> (a -> m b) -> m b

basic-prelude CorePrelude

Sequentially compose two actions, passing any value produced by the first as an argument to the second. 'as >>= bs' can be understood as the do expression
```
do a <- as
bs a
```
An alternative name for this function is 'bind', but some people may refer to it as 'flatMap', which results from it being equivalent to
```
\x f -> join (fmap f x) :: Monad m => m a -> (a -> m b) -> m b
```
which can be seen as mapping a value with Monad m => m a -> m (m b) and then 'flattening' m (m b) to m b using join.
(>>=) :: forall e s (a :: TYPE ra) (b :: TYPE rb) . Bind ra rb => Parser e s a -> (a -> Parser e s b) -> Parser e s b

bytesmith Data.Bytes.Parser.Rebindable

No documentation available.
(>>=) :: Monad m => m a -> (a -> m b) -> m b

classy-prelude ClassyPrelude

Sequentially compose two actions, passing any value produced by the first as an argument to the second. 'as >>= bs' can be understood as the do expression
```
do a <- as
bs a
```
An alternative name for this function is 'bind', but some people may refer to it as 'flatMap', which results from it being equivalent to
```
\x f -> join (fmap f x) :: Monad m => m a -> (a -> m b) -> m b
```
which can be seen as mapping a value with Monad m => m a -> m (m b) and then 'flattening' m (m b) to m b using join.
(>>=) :: Monad m => m a -> (a -> m b) -> m b

foundation Foundation

Sequentially compose two actions, passing any value produced by the first as an argument to the second. 'as >>= bs' can be understood as the do expression
```
do a <- as
bs a
```
An alternative name for this function is 'bind', but some people may refer to it as 'flatMap', which results from it being equivalent to
```
\x f -> join (fmap f x) :: Monad m => m a -> (a -> m b) -> m b
```
which can be seen as mapping a value with Monad m => m a -> m (m b) and then 'flattening' m (m b) to m b using join.
(>>=) :: Monad m => m a -> (a -> m b) -> m b

ghc-lib-parser GHC.Prelude.Basic

Sequentially compose two actions, passing any value produced by the first as an argument to the second. 'as >>= bs' can be understood as the do expression
```
do a <- as
bs a
```
An alternative name for this function is 'bind', but some people may refer to it as 'flatMap', which results from it being equivalent to
```
\x f -> join (fmap f x) :: Monad m => m a -> (a -> m b) -> m b
```
which can be seen as mapping a value with Monad m => m a -> m (m b) and then 'flattening' m (m b) to m b using join.
(>>=) :: Monad m => m a -> (a -> m b) -> m b

base-prelude BasePrelude.Operators

Sequentially compose two actions, passing any value produced by the first as an argument to the second. 'as >>= bs' can be understood as the do expression
```
do a <- as
bs a
```
An alternative name for this function is 'bind', but some people may refer to it as 'flatMap', which results from it being equivalent to
```
\x f -> join (fmap f x) :: Monad m => m a -> (a -> m b) -> m b
```
which can be seen as mapping a value with Monad m => m a -> m (m b) and then 'flattening' m (m b) to m b using join.
(>>=) :: Monad m => m a -> (a -> m b) -> m b

mixed-types-num Numeric.MixedTypes.PreludeHiding

Sequentially compose two actions, passing any value produced by the first as an argument to the second. 'as >>= bs' can be understood as the do expression
```
do a <- as
bs a
```
An alternative name for this function is 'bind', but some people may refer to it as 'flatMap', which results from it being equivalent to
```
\x f -> join (fmap f x) :: Monad m => m a -> (a -> m b) -> m b
```
which can be seen as mapping a value with Monad m => m a -> m (m b) and then 'flattening' m (m b) to m b using join.
(>>=) :: Monad m => m a -> (a -> m b) -> m b

protolude Protolude.Monad

Sequentially compose two actions, passing any value produced by the first as an argument to the second. 'as >>= bs' can be understood as the do expression
```
do a <- as
bs a
```
An alternative name for this function is 'bind', but some people may refer to it as 'flatMap', which results from it being equivalent to
```
\x f -> join (fmap f x) :: Monad m => m a -> (a -> m b) -> m b
```
which can be seen as mapping a value with Monad m => m a -> m (m b) and then 'flattening' m (m b) to m b using join.

type-spec	Test.TypeSpec.Internal.Apply

basic-prelude	BasicPrelude

basic-prelude	CorePrelude

bytesmith	Data.Bytes.Parser.Rebindable

classy-prelude	ClassyPrelude

foundation	Foundation

ghc-lib-parser	GHC.Prelude.Basic

base-prelude	BasePrelude.Operators

mixed-types-num	Numeric.MixedTypes.PreludeHiding

protolude	Protolude.Monad

Page 3 of many | Previous | Next