Safe HaskellSafe

Eta.Classes.Monad

Description

The Monad type class defines that a type can have an flatMap operation which can be used to sequence actions over the same type.

All types that implement Monad must implement Applicative.

The List, Maybe, and IO types are examples of instances of Monad.

>>> flatMap (\x -> [1 .. x]) [1, 2, 3]
[1,1,2,1,2,3]

Mnemonic: Sequenceable

Synopsis

Documentation

class Applicative m => Monad m where #

Minimal complete definition

(>>=)

Methods

(>>=) :: m a -> (a -> m b) -> m b #

Instances

Monad [] 

Methods

(>>=) :: [a] -> (a -> [b]) -> [b] #

(>>) :: [a] -> [b] -> [b]

return :: a -> [a]

fail :: String -> [a]

Monad Maybe 

Methods

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b #

(>>) :: Maybe a -> Maybe b -> Maybe b

return :: a -> Maybe a

fail :: String -> Maybe a

Monad IO 

Methods

(>>=) :: IO a -> (a -> IO b) -> IO b #

(>>) :: IO a -> IO b -> IO b

return :: a -> IO a

fail :: String -> IO a

Monad U1 

Methods

(>>=) :: U1 a -> (a -> U1 b) -> U1 b #

(>>) :: U1 a -> U1 b -> U1 b

return :: a -> U1 a

fail :: String -> U1 a

Monad Par1 

Methods

(>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b #

(>>) :: Par1 a -> Par1 b -> Par1 b

return :: a -> Par1 a

fail :: String -> Par1 a

Monad Sum 

Methods

(>>=) :: Sum a -> (a -> Sum b) -> Sum b #

(>>) :: Sum a -> Sum b -> Sum b

return :: a -> Sum a

fail :: String -> Sum a

Monad Product 

Methods

(>>=) :: Product a -> (a -> Product b) -> Product b #

(>>) :: Product a -> Product b -> Product b

return :: a -> Product a

fail :: String -> Product a

Monad Last 

Methods

(>>=) :: Last a -> (a -> Last b) -> Last b #

(>>) :: Last a -> Last b -> Last b

return :: a -> Last a

fail :: String -> Last a

Monad First 

Methods

(>>=) :: First a -> (a -> First b) -> First b #

(>>) :: First a -> First b -> First b

return :: a -> First a

fail :: String -> First a

Monad Dual 

Methods

(>>=) :: Dual a -> (a -> Dual b) -> Dual b #

(>>) :: Dual a -> Dual b -> Dual b

return :: a -> Dual a

fail :: String -> Dual a

Monad ((->) r) 

Methods

(>>=) :: (r -> a) -> (a -> r -> b) -> r -> b #

(>>) :: (r -> a) -> (r -> b) -> r -> b

return :: a -> r -> a

fail :: String -> r -> a

Monad (Either e) 

Methods

(>>=) :: Either e a -> (a -> Either e b) -> Either e b #

(>>) :: Either e a -> Either e b -> Either e b

return :: a -> Either e a

fail :: String -> Either e a

Monad f => Monad (Rec1 f) 

Methods

(>>=) :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b #

(>>) :: Rec1 f a -> Rec1 f b -> Rec1 f b

return :: a -> Rec1 f a

fail :: String -> Rec1 f a

Monoid a => Monad ((,) a) 

Methods

(>>=) :: (a, a) -> (a -> (a, b)) -> (a, b) #

(>>) :: (a, a) -> (a, b) -> (a, b)

return :: a -> (a, a)

fail :: String -> (a, a)

Monad m => Monad (WrappedMonad m) 

Methods

(>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b #

(>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b

return :: a -> WrappedMonad m a

fail :: String -> WrappedMonad m a

Monad (Proxy *) 

Methods

(>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b #

(>>) :: Proxy * a -> Proxy * b -> Proxy * b

return :: a -> Proxy * a

fail :: String -> Proxy * a

(Monad f, Monad g) => Monad ((:*:) f g) 

Methods

(>>=) :: (f :*: g) a -> (a -> (f :*: g) b) -> (f :*: g) b #

(>>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b

return :: a -> (f :*: g) a

fail :: String -> (f :*: g) a

Monad f => Monad (Alt * f) 

Methods

(>>=) :: Alt * f a -> (a -> Alt * f b) -> Alt * f b #

(>>) :: Alt * f a -> Alt * f b -> Alt * f b

return :: a -> Alt * f a

fail :: String -> Alt * f a

Monad f => Monad (M1 i c f) 

Methods

(>>=) :: M1 i c f a -> (a -> M1 i c f b) -> M1 i c f b #

(>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b

return :: a -> M1 i c f a

fail :: String -> M1 i c f a

flatMap :: Monad m => (a -> m b) -> m a -> m b #

(|>>) :: Monad m => m a -> (a -> m b) -> m b #

Flatmaps the function of the right over the Monad of the left

>> readFile "data.txt" |>> printLine
"This is some data stored in data.txt"

(<<|) :: Monad m => (a -> m b) -> m a -> m b #

Flatmaps the function of the left over the Monad of the left

>> printLine <<| readFile "data.txt"
"This is some data stored in data.txt"

Creates a new function that can be flatmapped by composing two functions:

 >> readAndPrint = readFile >=> printLine
 >> readAndPrint "data.txt"
 "This is some data stored in data.txt"

Sometimes referred as Kleisli composition

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c #

Inverted '(>=>)'

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c #