Control.Monad

Авторское право	(c) Университет Глазго, 2001
Лицензия	В стиле BSD (см. файл libraries/base/LICENSE)
Сопровождающий	libraries@haskell.org
Стабильность	предварительная
Переносимость	переносимый
Безопасный Haskell	Безопасный
Язык	Haskell2010

Содержание

Классы функторов и монад
Функции

Описание

Классы Functor, Monad и MonadPlus с несколькими полезными операциями над монадами.

Классы функторов и монад

class Functor (f :: Type -> Type) where Источник

Тип f является функтором, если он предоставляет функцию fmap, которая для любых типов a и b позволяет применить любую функцию из (a -> b), чтобы преобразовать f a в f b, сохраняя структуру f. Кроме того, f должен удовлетворять следующим законам:

Тождественность: fmap id == id
Композиция: fmap (f . g) == fmap f . fmap g

Обратите внимание: второй закон следует из свободной теоремы для типа fmap и первого закона, поэтому достаточно проверить выполнение первого условия. Объяснение можно найти в этих статьях на School of Haskell или у Дэвида Лупошчински.

Минимальное полное определение

fmap

Методы

fmap :: (a -> b) -> f a -> f b Источник

fmap используется для применения функции типа (a -> b) к значению типа f a, где f — функтор, чтобы получить значение типа f b. Обратите внимание, что для любого конструктора типов с более чем одним параметром (например, Either) с помощью fmap можно изменить только последний параметр типа (например, b в Either a b).

Для некоторых конструкторов типов с двумя или более параметрами существует экземпляр Bifunctor, позволяющий выполнять отображение как по последнему, так и по предпоследнему параметру.

Примеры

Развернуть

Преобразование Maybe Int в Maybe String с помощью show:

>>> fmap show Nothing
Nothing
>>> fmap show (Just 3)
Just "3"

Преобразование Either Int Int в Either Int String с помощью show:

>>> fmap show (Left 17)
Left 17
>>> fmap show (Right 17)
Right "17"

Удвоение каждого элемента списка:

>>> fmap (*2) [1,2,3]
[2,4,6]

Применение even ко второму элементу пары:

>>> fmap even (2,2)
(2,True)

Может показаться удивительным, что функция применяется только к последнему элементу кортежа, тогда как в приведённом выше примере со списком она применяется ко всем элементам списка. Чтобы понять причину, вспомните, что кортежи — это конструкторы типов с несколькими параметрами типа: кортеж из 3 элементов (a,b,c) также можно записать как (,,) a b c, а его экземпляр Functor определён для Functor ((,,) a b) (то есть только третий параметр можно свободно изменять с помощью fmap).

Это объясняет, почему fmap можно использовать с кортежами, содержащими значения разных типов, как в следующем примере:

>>> fmap even ("hello", 1.0, 4)
("hello",1.0,True)

(<$) :: a -> f b -> f a infixl 4 Источник

Заменяет все значения во входных данных одним и тем же значением. Определение по умолчанию — fmap . const, но его можно заменить более эффективной версией.

Примеры

Развернуть

Выполнение вычисления с Maybe и замена результата постоянным значением, если он равен Just:

>>> 'a' <$ Just 2
Just 'a'
>>> 'a' <$ Nothing
Nothing

Экземпляры

Подробная информация об экземплярах

Functor Complex Источник	Начиная с: base-4.9.0.0
Подробная информация об экземпляре Определён в Data.Complex Методы fmap :: (a -> b) -> Complex a -> Complex b Источник (<$) :: a -> Complex b -> Complex a Источник
Functor First Источник	Начиная с: base-4.9.0.0
Подробная информация об экземпляре Определён в Data.Semigroup Методы fmap :: (a -> b) -> First a -> First b Источник (<$) :: a -> First b -> First a Источник
Functor Last Источник	Начиная с: base-4.9.0.0
Подробная информация об экземпляре Определён в Data.Semigroup Методы fmap :: (a -> b) -> Last a -> Last b Источник (<$) :: a -> Last b -> Last a Источник
Functor Max Источник	Начиная с: base-4.9.0.0
Подробная информация об экземпляре Определён в Data.Semigroup Методы fmap :: (a -> b) -> Max a -> Max b Источник (<$) :: a -> Max b -> Max a Источник
Functor Min Источник	Начиная с: base-4.9.0.0
Подробная информация об экземпляре Определён в Data.Semigroup Методы fmap :: (a -> b) -> Min a -> Min b Источник (<$) :: a -> Min b -> Min a Источник
Functor ArgDescr Источник	Начиная с: base-4.7.0.0
Подробная информация об экземпляре Определён в System.Console.GetOpt Методы fmap :: (a -> b) -> ArgDescr a -> ArgDescr b Источник (<$) :: a -> ArgDescr b -> ArgDescr a Источник
Functor ArgOrder Источник	Начиная с: base-4.7.0.0
Подробная информация об экземпляре Определён в System.Console.GetOpt Методы fmap :: (a -> b) -> ArgOrder a -> ArgOrder b Источник (<$) :: a -> ArgOrder b -> ArgOrder a Источник
Functor OptDescr Источник	Начиная с: base-4.7.0.0
Подробная информация об экземпляре Определён в System.Console.GetOpt Методы fmap :: (a -> b) -> OptDescr a -> OptDescr b Источник (<$) :: a -> OptDescr b -> OptDescr a Источник
Functor NonEmpty Источник	Начиная с: base-4.9.0.0
Подробная информация об экземпляре Определён в GHC.Internal.Data.NonEmpty Методы fmap :: (a -> b) -> NonEmpty a -> NonEmpty b Источник (<$) :: a -> NonEmpty b -> NonEmpty a Источник
Functor STM Источник	Начиная с: base-4.3.0.0
Подробная информация об экземпляре Определён в GHC.Internal.Conc.Sync Методы fmap :: (a -> b) -> STM a -> STM b Источник (<$) :: a -> STM b -> STM a Источник
Functor Handler Источник	Начиная с: base-4.6.0.0
Подробная информация об экземпляре Определён в GHC.Internal.Control.Exception Методы fmap :: (a -> b) -> Handler a -> Handler b Источник (<$) :: a -> Handler b -> Handler a Источник
Functor Identity Источник	Начиная с: base-4.8.0.0
Подробная информация об экземпляре Определён в GHC.Internal.Data.Functor.Identity Методы fmap :: (a -> b) -> Identity a -> Identity b Источник (<$) :: a -> Identity b -> Identity a Источник
Functor First Источник	Начиная с: base-4.8.0.0
Подробная информация об экземпляре Определён в GHC.Internal.Data.Monoid Методы fmap :: (a -> b) -> First a -> First b Источник (<$) :: a -> First b -> First a Источник
Functor Last Источник	Начиная с: base-4.8.0.0
Подробная информация об экземпляре Определён в GHC.Internal.Data.Monoid Методы fmap :: (a -> b) -> Last a -> Last b Источник (<$) :: a -> Last b -> Last a Источник
Functor Down Источник	Начиная с: base-4.11.0.0
Подробная информация об экземпляре Определён в GHC.Internal.Data.Ord Методы fmap :: (a -> b) -> Down a -> Down b Источник (<$) :: a -> Down b -> Down a Источник
Functor Dual Источник	Начиная с: base-4.8.0.0
Подробная информация об экземпляре Определён в GHC.Internal.Data.Semigroup.Internal Методы fmap :: (a -> b) -> Dual a -> Dual b Источник (<$) :: a -> Dual b -> Dual a Источник
Functor Product Источник	Начиная с: base-4.8.0.0
Подробная информация об экземпляре Определён в GHC.Internal.Data.Semigroup.Internal Методы fmap :: (a -> b) -> Product a -> Product b Источник (<$) :: a -> Product b -> Product a Источник
Functor Sum Источник	Начиная с: base-4.8.0.0
Подробная информация об экземпляре Определён в GHC.Internal.Data.Semigroup.Internal Методы fmap :: (a -> b) -> Sum a -> Sum b Источник (<$) :: a -> Sum b -> Sum a Источник
Functor ZipList Источник	Начиная с: base-2.1
Подробная информация об экземпляре Определён в GHC.Internal.Functor.ZipList Методы fmap :: (a -> b) -> ZipList a -> ZipList b Источник (<$) :: a -> ZipList b -> ZipList a Источник
Functor NoIO Источник	Начиная с: base-4.8.0.0
Подробная информация об экземпляре Определён в GHC.Internal.GHCi Методы fmap :: (a -> b) -> NoIO a -> NoIO b Источник (<$) :: a -> NoIO b -> NoIO a Источник
Functor Par1 Источник	Начиная с: base-4.9.0.0
Подробная информация об экземпляре Определён в GHC.Internal.Generics Методы fmap :: (a -> b) -> Par1 a -> Par1 b Источник (<$) :: a -> Par1 b -> Par1 a Источник
Functor GenClosure Источник

Сведения об экземпляре Определено в GHC.Internal.Heap.Closures Методы fmap :: (a -> b) -> GenClosure a -> GenClosure b Источник (<$) :: a -> GenClosure b -> GenClosure a Источник
Functor GenStackField Источник
Сведения об экземпляре Определено в GHC.Internal.Heap.Closures Методы fmap :: (a -> b) -> GenStackField a -> GenStackField b Источник (<$) :: a -> GenStackField b -> GenStackField a Источник
Functor GenStackFrame Источник
Сведения об экземпляре Определено в GHC.Internal.Heap.Closures Методы fmap :: (a -> b) -> GenStackFrame a -> GenStackFrame b Источник (<$) :: a -> GenStackFrame b -> GenStackFrame a Источник
Functor GenStgStackClosure Источник
Сведения об экземпляре Определено в GHC.Internal.Heap.Closures Методы fmap :: (a -> b) -> GenStgStackClosure a -> GenStgStackClosure b Источник (<$) :: a -> GenStgStackClosure b -> GenStgStackClosure a Источник
Functor Q Источник
Сведения об экземпляре Определено в GHC.Internal.TH.Syntax Методы fmap :: (a -> b) -> Q a -> Q b Источник (<$) :: a -> Q b -> Q a Источник
Functor TyVarBndr Источник
Сведения об экземпляре Определено в GHC.Internal.TH.Syntax Методы fmap :: (a -> b) -> TyVarBndr a -> TyVarBndr b Источник (<$) :: a -> TyVarBndr b -> TyVarBndr a Источник
Functor P Источник	Начиная с: base-4.8.0.0
Сведения об экземпляре Определено в GHC.Internal.Text.ParserCombinators.ReadP Методы fmap :: (a -> b) -> P a -> P b Источник (<$) :: a -> P b -> P a Источник
Functor ReadP Источник	Начиная с: base-2.1
Сведения об экземпляре Определено в GHC.Internal.Text.ParserCombinators.ReadP Методы fmap :: (a -> b) -> ReadP a -> ReadP b Источник (<$) :: a -> ReadP b -> ReadP a Источник
Functor ReadPrec Источник	Начиная с: base-2.1
Сведения об экземпляре Определено в GHC.Internal.Text.ParserCombinators.ReadPrec Методы fmap :: (a -> b) -> ReadPrec a -> ReadPrec b Источник (<$) :: a -> ReadPrec b -> ReadPrec a Источник
Functor IO Источник	Начиная с: base-2.1
Сведения об экземпляре Определено в GHC.Internal.Base Методы fmap :: (a -> b) -> IO a -> IO b Источник (<$) :: a -> IO b -> IO a Источник
Functor Maybe Источник	Начиная с: base-2.1
Сведения об экземпляре Определено в GHC.Internal.Base Методы fmap :: (a -> b) -> Maybe a -> Maybe b Источник (<$) :: a -> Maybe b -> Maybe a Источник
Functor Solo Источник	Начиная с: base-4.15
Сведения об экземпляре Определено в GHC.Internal.Base Методы fmap :: (a -> b) -> Solo a -> Solo b Источник (<$) :: a -> Solo b -> Solo a Источник
Functor [] Источник	Начиная с: base-2.1
Сведения об экземпляре Определено в GHC.Internal.Base Методы fmap :: (a -> b) -> [a] -> [b] Источник (<$) :: a -> [b] -> [a] Источник
Monad m => Functor (WrappedMonad m) Источник	Начиная с: base-2.1
Сведения об экземпляре Определено в Control.Applicative Методы fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b Источник (<$) :: a -> WrappedMonad m b -> WrappedMonad m a Источник
Functor (Arg a) Источник	Начиная с: base-4.9.0.0
Сведения об экземпляре Определено в Data.Semigroup Методы fmap :: (a0 -> b) -> Arg a a0 -> Arg a b Источник (<$) :: a0 -> Arg a b -> Arg a a0 Источник
Functor (Array i) Источник	Начиная с: base-2.1
Сведения об экземпляре Определено в GHC.Internal.Arr Методы fmap :: (a -> b) -> Array i a -> Array i b Источник (<$) :: a -> Array i b -> Array i a Источник
Arrow a => Functor (ArrowMonad a) Источник	Начиная с: base-4.6.0.0
Сведения об экземпляре Определено в GHC.Internal.Control.Arrow Методы fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b Источник (<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0 Источник
Functor (ST s) Источник	Начиная с: base-2.1
Сведения об экземпляре Определено в GHC.Internal.Control.Monad.ST.Lazy.Imp Методы fmap :: (a -> b) -> ST s a -> ST s b Источник (<$) :: a -> ST s b -> ST s a Источник
Functor (Either a) Источник	Начиная с: base-3.0
Сведения об экземпляре Определено в GHC.Internal.Data.Either Методы fmap :: (a0 -> b) -> Either a a0 -> Either a b Источник (<$) :: a0 -> Either a b -> Either a a0 Источник

Functor (StateL s) Источник	Начиная с: base-4.0
Подробности экземпляра Определено в GHC.Internal.Data.Functor.Utils Методы fmap :: (a -> b) -> StateL s a -> StateL s b Источник (<$) :: a -> StateL s b -> StateL s a Источник
Functor (StateR s) Источник	Начиная с: base-4.0
Подробности экземпляра Определено в GHC.Internal.Data.Functor.Utils Методы fmap :: (a -> b) -> StateR s a -> StateR s b Источник (<$) :: a -> StateR s b -> StateR s a Источник
Functor (Proxy :: Type -> Type) Источник	Начиная с: base-4.7.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Proxy Методы fmap :: (a -> b) -> Proxy a -> Proxy b Источник (<$) :: a -> Proxy b -> Proxy a Источник
Functor (U1 :: Type -> Type) Источник	Начиная с: base-4.9.0.0
Подробности экземпляра Определено в GHC.Internal.Generics Методы fmap :: (a -> b) -> U1 a -> U1 b Источник (<$) :: a -> U1 b -> U1 a Источник
Functor (V1 :: Type -> Type) Источник	Начиная с: base-4.9.0.0
Подробности экземпляра Определено в GHC.Internal.Generics Методы fmap :: (a -> b) -> V1 a -> V1 b Источник (<$) :: a -> V1 b -> V1 a Источник
Functor (ST s) Источник	Начиная с: base-2.1
Подробности экземпляра Определено в GHC.Internal.ST Методы fmap :: (a -> b) -> ST s a -> ST s b Источник (<$) :: a -> ST s b -> ST s a Источник
Functor ((,) a) Источник	Начиная с: base-2.1
Подробности экземпляра Определено в GHC.Internal.Base Методы fmap :: (a0 -> b) -> (a, a0) -> (a, b) Источник (<$) :: a0 -> (a, b) -> (a, a0) Источник
Arrow a => Functor (WrappedArrow a b) Источник	Начиная с: base-2.1
Подробности экземпляра Определено в Control.Applicative Методы fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 Источник (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 Источник
Functor m => Functor (Kleisli m a) Источник	Начиная с: base-4.14.0.0
Подробности экземпляра Определено в GHC.Internal.Control.Arrow Методы fmap :: (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b Источник (<$) :: a0 -> Kleisli m a b -> Kleisli m a a0 Источник
Functor (Const m :: Type -> Type) Источник	Начиная с: base-2.1
Подробности экземпляра Определено в GHC.Internal.Data.Functor.Const Методы fmap :: (a -> b) -> Const m a -> Const m b Источник (<$) :: a -> Const m b -> Const m a Источник
Monad m => Functor (StateT s m) Источник	Начиная с: base-4.18.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Functor.Utils Методы fmap :: (a -> b) -> StateT s m a -> StateT s m b Источник (<$) :: a -> StateT s m b -> StateT s m a Источник
Functor f => Functor (Ap f) Источник	Начиная с: base-4.12.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Monoid Методы fmap :: (a -> b) -> Ap f a -> Ap f b Источник (<$) :: a -> Ap f b -> Ap f a Источник
Functor f => Functor (Alt f) Источник	Начиная с: base-4.8.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Semigroup.Internal Методы fmap :: (a -> b) -> Alt f a -> Alt f b Источник (<$) :: a -> Alt f b -> Alt f a Источник
(Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f) Источник	Начиная с: base-4.17.0.0
Подробности экземпляра Определено в GHC.Internal.Generics Методы fmap :: (a -> b) -> Generically1 f a -> Generically1 f b Источник (<$) :: a -> Generically1 f b -> Generically1 f a Источник
Functor f => Functor (Rec1 f) Источник	Начиная с: base-4.9.0.0
Подробности экземпляра Определено в GHC.Internal.Generics Методы fmap :: (a -> b) -> Rec1 f a -> Rec1 f b Источник (<$) :: a -> Rec1 f b -> Rec1 f a Источник
Functor (URec (Ptr ()) :: Type -> Type) Источник	Начиная с: base-4.9.0.0
Подробности экземпляра Определено в GHC.Internal.Generics Методы fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b Источник (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a Источник
Functor (URec Char :: Type -> Type) Источник	Начиная с: base-4.9.0.0
Подробности экземпляра Определено в GHC.Internal.Generics Методы fmap :: (a -> b) -> URec Char a -> URec Char b Источник (<$) :: a -> URec Char b -> URec Char a Источник
Functor (URec Double :: Type -> Type) Источник	Начиная с: base-4.9.0.0
Подробности экземпляра Определено в GHC.Internal.Generics Методы fmap :: (a -> b) -> URec Double a -> URec Double b Источник (<$) :: a -> URec Double b -> URec Double a Источник

Functor (URec Float :: Type -> Type) Источник	Начиная с: base-4.9.0.0
Сведения об экземпляре Определён в GHC.Internal.Generics Методы fmap :: (a -> b) -> URec Float a -> URec Float b Источник (<$) :: a -> URec Float b -> URec Float a Источник
Functor (URec Int :: Type -> Type) Источник	Начиная с: base-4.9.0.0
Сведения об экземпляре Определён в GHC.Internal.Generics Методы fmap :: (a -> b) -> URec Int a -> URec Int b Источник (<$) :: a -> URec Int b -> URec Int a Источник
Functor (URec Word :: Type -> Type) Источник	Начиная с: base-4.9.0.0
Сведения об экземпляре Определён в GHC.Internal.Generics Методы fmap :: (a -> b) -> URec Word a -> URec Word b Источник (<$) :: a -> URec Word b -> URec Word a Источник
Functor ((,,) a b) Источник	Начиная с: base-4.14.0.0
Сведения об экземпляре Определён в GHC.Internal.Base Методы fmap :: (a0 -> b0) -> (a, b, a0) -> (a, b, b0) Источник (<$) :: a0 -> (a, b, b0) -> (a, b, a0) Источник
(Functor f, Functor g) => Functor (Product f g) Источник	Начиная с: base-4.9.0.0
Сведения об экземпляре Определён в Data.Functor.Product Методы fmap :: (a -> b) -> Product f g a -> Product f g b Источник (<$) :: a -> Product f g b -> Product f g a Источник
(Functor f, Functor g) => Functor (Sum f g) Источник	Начиная с: base-4.9.0.0
Сведения об экземпляре Определён в Data.Functor.Sum Методы fmap :: (a -> b) -> Sum f g a -> Sum f g b Источник (<$) :: a -> Sum f g b -> Sum f g a Источник
(Functor f, Functor g) => Functor (f :*: g) Источник	Начиная с: base-4.9.0.0
Сведения об экземпляре Определён в GHC.Internal.Generics Методы fmap :: (a -> b) -> (f :: g) a -> (f :: g) b Источник (<$) :: a -> (f :: g) b -> (f :: g) a Источник
(Functor f, Functor g) => Functor (f :+: g) Источник	Начиная с: base-4.9.0.0
Сведения об экземпляре Определён в GHC.Internal.Generics Методы fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b Источник (<$) :: a -> (f :+: g) b -> (f :+: g) a Источник
Functor (K1 i c :: Type -> Type) Источник	Начиная с: base-4.9.0.0
Сведения об экземпляре Определён в GHC.Internal.Generics Методы fmap :: (a -> b) -> K1 i c a -> K1 i c b Источник (<$) :: a -> K1 i c b -> K1 i c a Источник
Functor ((,,,) a b c) Источник	Начиная с: base-4.14.0.0
Сведения об экземпляре Определён в GHC.Internal.Base Методы fmap :: (a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) Источник (<$) :: a0 -> (a, b, c, b0) -> (a, b, c, a0) Источник
Functor ((->) r) Источник	Начиная с: base-2.1
Сведения об экземпляре Определён в GHC.Internal.Base Методы fmap :: (a -> b) -> (r -> a) -> r -> b Источник (<$) :: a -> (r -> b) -> r -> a Источник
(Functor f, Functor g) => Functor (Compose f g) Источник	Начиная с: base-4.9.0.0
Сведения об экземпляре Определён в Data.Functor.Compose Методы fmap :: (a -> b) -> Compose f g a -> Compose f g b Источник (<$) :: a -> Compose f g b -> Compose f g a Источник
(Functor f, Functor g) => Functor (f :.: g) Источник	Начиная с: base-4.9.0.0
Сведения об экземпляре Определён в GHC.Internal.Generics Методы fmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b Источник (<$) :: a -> (f :.: g) b -> (f :.: g) a Источник
Functor f => Functor (M1 i c f) Источник	Начиная с: base-4.9.0.0
Сведения об экземпляре Определён в GHC.Internal.Generics Методы fmap :: (a -> b) -> M1 i c f a -> M1 i c f b Источник (<$) :: a -> M1 i c f b -> M1 i c f a Источник
Functor ((,,,,) a b c d) Источник	Начиная с: base-4.18.0.0
Сведения об экземпляре Определён в GHC.Internal.Base Методы fmap :: (a0 -> b0) -> (a, b, c, d, a0) -> (a, b, c, d, b0) Источник (<$) :: a0 -> (a, b, c, d, b0) -> (a, b, c, d, a0) Источник
Functor ((,,,,,) a b c d e) Источник	Начиная с: base-4.18.0.0
Сведения об экземпляре Определён в GHC.Internal.Base Методы fmap :: (a0 -> b0) -> (a, b, c, d, e, a0) -> (a, b, c, d, e, b0) Источник (<$) :: a0 -> (a, b, c, d, e, b0) -> (a, b, c, d, e, a0) Источник
Functor ((,,,,,,) a b c d e f) Источник	Начиная с: base-4.18.0.0
Сведения об экземпляре Определён в GHC.Internal.Base Методы fmap :: (a0 -> b0) -> (a, b, c, d, e, f, a0) -> (a, b, c, d, e, f, b0) Источник (<$) :: a0 -> (a, b, c, d, e, f, b0) -> (a, b, c, d, e, f, a0) Источник

class Applicative m => Monad (m :: Type -> Type) where Источник

Класс Monad определяет базовые операции над монадой — понятием из раздела математики, известного как теория категорий. Однако с точки зрения программиста на Haskell лучше всего рассматривать монаду как абстрактный тип данных, представляющий действия. Выражения do в Haskell предоставляют удобный синтаксис для записи монадических выражений.

Экземпляры Monad должны удовлетворять следующим законам:

Левая единица: return a >>= k = k a
Правая единица: m >>= return = m
Ассоциативность: m >>= (\x -> k x >>= h) = (m >>= k) >>= h

Кроме того, операции Monad и Applicative должны соотноситься следующим образом:

```
pure = return
```

m1 <*> m2 = m1 >>= (\x1 -> m2 >>= (\x2 -> return (x1 x2)))

Из приведённых выше законов следуют:

```
fmap f xs  =  xs >>= return . f
```
```
(>>) = (*>)
```

а также то, что pure и (<*>) удовлетворяют законам аппликативного функтора.

Экземпляры Monad для List, Maybe и IO, определённые в Prelude, удовлетворяют этим законам.

Минимальное полное определение

(>>=)

Методы

(>>=) :: m a -> (a -> m b) -> m b infixl 1 Источник

Последовательно объединяет два действия, передавая значение, полученное в результате первого, в качестве аргумента второму.

'as >>= bs' можно понимать как выражение do

do a <- as
   bs a

Альтернативное название этой функции — 'bind', но некоторые называют её 'flatMap'; это название связано с тем, что функция эквивалентна

\x f -> join (fmap f x) :: Monad m => m a -> (a -> m b) -> m b

что можно рассматривать как отображение значения с помощью Monad m => m a -> m (m b), а затем «сведение» m (m b) к m b с помощью join.

(>>) :: m a -> m b -> m b infixl 1 Источник

Последовательно объединяет два действия, отбрасывая значение, полученное в результате первого, подобно операторам последовательного выполнения (например, точке с запятой) в императивных языках.

'as >> bs' можно понимать как выражение do

do as
   bs

или через (>>=) как

as >>= const bs

return :: a -> m a Источник

Внедряет значение в монадический тип. Эта функция не должна отличаться от своей реализации по умолчанию в виде pure. Существование этой функции объясняется лишь историческими причинами.

Экземпляры

Подробности экземпляров

Monad Complex Исходный код	Начиная с: base-4.9.0.0
Подробности экземпляра Определено в Data.Complex Методы (>>=) :: Complex a -> (a -> Complex b) -> Complex b Исходный код (>>) :: Complex a -> Complex b -> Complex b Исходный код return :: a -> Complex a Исходный код
Monad First Исходный код	Начиная с: base-4.9.0.0
Подробности экземпляра Определено в Data.Semigroup Методы (>>=) :: First a -> (a -> First b) -> First b Исходный код (>>) :: First a -> First b -> First b Исходный код return :: a -> First a Исходный код
Monad Last Исходный код	Начиная с: base-4.9.0.0
Подробности экземпляра Определено в Data.Semigroup Методы (>>=) :: Last a -> (a -> Last b) -> Last b Исходный код (>>) :: Last a -> Last b -> Last b Исходный код return :: a -> Last a Исходный код
Monad Max Исходный код	Начиная с: base-4.9.0.0
Подробности экземпляра Определено в Data.Semigroup Методы (>>=) :: Max a -> (a -> Max b) -> Max b Исходный код (>>) :: Max a -> Max b -> Max b Исходный код return :: a -> Max a Исходный код
Monad Min Исходный код	Начиная с: base-4.9.0.0
Подробности экземпляра Определено в Data.Semigroup Методы (>>=) :: Min a -> (a -> Min b) -> Min b Исходный код (>>) :: Min a -> Min b -> Min b Исходный код return :: a -> Min a Исходный код
Monad NonEmpty Исходный код	Начиная с: base-4.9.0.0
Подробности экземпляра Определено в GHC.Internal.Data.NonEmpty Методы (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b Исходный код (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b Исходный код return :: a -> NonEmpty a Исходный код
Monad STM Исходный код	Начиная с: base-4.3.0.0
Подробности экземпляра Определено в GHC.Internal.Conc.Sync Методы (>>=) :: STM a -> (a -> STM b) -> STM b Исходный код (>>) :: STM a -> STM b -> STM b Исходный код return :: a -> STM a Исходный код
Monad Identity Исходный код	Начиная с: base-4.8.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Functor.Identity Методы (>>=) :: Identity a -> (a -> Identity b) -> Identity b Исходный код (>>) :: Identity a -> Identity b -> Identity b Исходный код return :: a -> Identity a Исходный код
Monad First Исходный код	Начиная с: base-4.8.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Monoid Методы (>>=) :: First a -> (a -> First b) -> First b Исходный код (>>) :: First a -> First b -> First b Исходный код return :: a -> First a Исходный код
Monad Last Исходный код	Начиная с: base-4.8.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Monoid Методы (>>=) :: Last a -> (a -> Last b) -> Last b Исходный код (>>) :: Last a -> Last b -> Last b Исходный код return :: a -> Last a Исходный код
Monad Down Исходный код	Начиная с: base-4.11.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Ord Методы (>>=) :: Down a -> (a -> Down b) -> Down b Исходный код (>>) :: Down a -> Down b -> Down b Исходный код return :: a -> Down a Исходный код
Monad Dual Исходный код	Начиная с: base-4.8.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Semigroup.Internal Методы (>>=) :: Dual a -> (a -> Dual b) -> Dual b Исходный код (>>) :: Dual a -> Dual b -> Dual b Исходный код return :: a -> Dual a Исходный код
Monad Product Исходный код	Начиная с: base-4.8.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Semigroup.Internal Методы (>>=) :: Product a -> (a -> Product b) -> Product b Исходный код (>>) :: Product a -> Product b -> Product b Исходный код return :: a -> Product a Исходный код
Monad Sum Исходный код	Начиная с: base-4.8.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Semigroup.Internal Методы (>>=) :: Sum a -> (a -> Sum b) -> Sum b Исходный код (>>) :: Sum a -> Sum b -> Sum b Исходный код return :: a -> Sum a Исходный код
Monad NoIO Исходный код	Начиная с: base-4.4.0.0
Подробности экземпляра Определено в GHC.Internal.GHCi Методы (>>=) :: NoIO a -> (a -> NoIO b) -> NoIO b Исходный код (>>) :: NoIO a -> NoIO b -> NoIO b Исходный код return :: a -> NoIO a Исходный код
Monad Par1 Исходный код	Начиная с: base-4.9.0.0
Подробности экземпляра Определено в GHC.Internal.Generics Методы (>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b Исходный код (>>) :: Par1 a -> Par1 b -> Par1 b Исходный код return :: a -> Par1 a Исходный код
Monad Q Исходный код

Подробности экземпляра Определено в GHC.Internal.TH.Syntax Методы (>>=) :: Q a -> (a -> Q b) -> Q b Источник (>>) :: Q a -> Q b -> Q b Источник return :: a -> Q a Источник
Monad P Источник	С версии: base-2.1
Подробности экземпляра Определено в GHC.Internal.Text.ParserCombinators.ReadP Методы (>>=) :: P a -> (a -> P b) -> P b Источник (>>) :: P a -> P b -> P b Источник return :: a -> P a Источник
Monad ReadP Источник	С версии: base-2.1
Подробности экземпляра Определено в GHC.Internal.Text.ParserCombinators.ReadP Методы (>>=) :: ReadP a -> (a -> ReadP b) -> ReadP b Источник (>>) :: ReadP a -> ReadP b -> ReadP b Источник return :: a -> ReadP a Источник
Monad ReadPrec Источник	С версии: base-2.1
Подробности экземпляра Определено в GHC.Internal.Text.ParserCombinators.ReadPrec Методы (>>=) :: ReadPrec a -> (a -> ReadPrec b) -> ReadPrec b Источник (>>) :: ReadPrec a -> ReadPrec b -> ReadPrec b Источник return :: a -> ReadPrec a Источник
Monad IO Источник	С версии: base-2.1
Подробности экземпляра Определено в GHC.Internal.Base Методы (>>=) :: IO a -> (a -> IO b) -> IO b Источник (>>) :: IO a -> IO b -> IO b Источник return :: a -> IO a Источник
Monad Maybe Источник	С версии: base-2.1
Подробности экземпляра Определено в GHC.Internal.Base Методы (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b Источник (>>) :: Maybe a -> Maybe b -> Maybe b Источник return :: a -> Maybe a Источник
Monad Solo Источник	С версии: base-4.15
Подробности экземпляра Определено в GHC.Internal.Base Методы (>>=) :: Solo a -> (a -> Solo b) -> Solo b Источник (>>) :: Solo a -> Solo b -> Solo b Источник return :: a -> Solo a Источник
Monad [] Источник	С версии: base-2.1
Подробности экземпляра Определено в GHC.Internal.Base Методы (>>=) :: [a] -> (a -> [b]) -> [b] Источник (>>) :: [a] -> [b] -> [b] Источник return :: a -> [a] Источник
Monad m => Monad (WrappedMonad m) Источник	С версии: base-4.7.0.0
Подробности экземпляра Определено в Control.Applicative Методы (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b Источник (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Источник return :: a -> WrappedMonad m a Источник
ArrowApply a => Monad (ArrowMonad a) Источник	С версии: base-2.1
Подробности экземпляра Определено в GHC.Internal.Control.Arrow Методы (>>=) :: ArrowMonad a a0 -> (a0 -> ArrowMonad a b) -> ArrowMonad a b Источник (>>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b Источник return :: a0 -> ArrowMonad a a0 Источник
Monad (ST s) Источник	С версии: base-2.1
Подробности экземпляра Определено в GHC.Internal.Control.Monad.ST.Lazy.Imp Методы (>>=) :: ST s a -> (a -> ST s b) -> ST s b Источник (>>) :: ST s a -> ST s b -> ST s b Источник return :: a -> ST s a Источник
Monad (Either e) Источник	С версии: base-4.4.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Either Методы (>>=) :: Either e a -> (a -> Either e b) -> Either e b Источник (>>) :: Either e a -> Either e b -> Either e b Источник return :: a -> Either e a Источник
Monad (Proxy :: Type -> Type) Источник	С версии: base-4.7.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Proxy Методы (>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b Источник (>>) :: Proxy a -> Proxy b -> Proxy b Источник return :: a -> Proxy a Источник
Monad (U1 :: Type -> Type) Источник	С версии: base-4.9.0.0
Подробности экземпляра Определено в GHC.Internal.Generics Методы (>>=) :: U1 a -> (a -> U1 b) -> U1 b Источник (>>) :: U1 a -> U1 b -> U1 b Источник return :: a -> U1 a Источник
Monad (ST s) Источник	С версии: base-2.1
Подробности экземпляра Определено в GHC.Internal.ST Методы (>>=) :: ST s a -> (a -> ST s b) -> ST s b Источник (>>) :: ST s a -> ST s b -> ST s b Источник return :: a -> ST s a Источник
Monoid a => Monad ((,) a) Источник	С версии: base-4.9.0.0
Подробности экземпляра Определено в GHC.Internal.Base Методы (>>=) :: (a, a0) -> (a0 -> (a, b)) -> (a, b) Источник (>>) :: (a, a0) -> (a, b) -> (a, b) Источник return :: a0 -> (a, a0) Источник
Monad m => Monad (Kleisli m a) Источник	С версии: base-4.14.0.0

Подробности экземпляра Определено в GHC.Internal.Control.Arrow Методы (>>=) :: Kleisli m a a0 -> (a0 -> Kleisli m a b) -> Kleisli m a b Источник (>>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b Источник return :: a0 -> Kleisli m a a0 Источник
Monad m => Monad (StateT s m) Источник	С версии: base-4.18.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Functor.Utils Методы (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b Источник (>>) :: StateT s m a -> StateT s m b -> StateT s m b Источник return :: a -> StateT s m a Источник
Monad f => Monad (Ap f) Источник	С версии: base-4.12.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Monoid Методы (>>=) :: Ap f a -> (a -> Ap f b) -> Ap f b Источник (>>) :: Ap f a -> Ap f b -> Ap f b Источник return :: a -> Ap f a Источник
Monad f => Monad (Alt f) Источник	С версии: base-4.8.0.0
Подробности экземпляра Определено в GHC.Internal.Data.Semigroup.Internal Методы (>>=) :: Alt f a -> (a -> Alt f b) -> Alt f b Источник (>>) :: Alt f a -> Alt f b -> Alt f b Источник return :: a -> Alt f a Источник
Monad f => Monad (Rec1 f) Источник	С версии: base-4.9.0.0
Подробности экземпляра Определено в GHC.Internal.Generics Методы (>>=) :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b Источник (>>) :: Rec1 f a -> Rec1 f b -> Rec1 f b Источник return :: a -> Rec1 f a Источник
(Monoid a, Monoid b) => Monad ((,,) a b) Источник	С версии: base-4.14.0.0
Подробности экземпляра Определено в GHC.Internal.Base Методы (>>=) :: (a, b, a0) -> (a0 -> (a, b, b0)) -> (a, b, b0) Источник (>>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0) Источник return :: a0 -> (a, b, a0) Источник
(Monad f, Monad g) => Monad (Product f g) Источник	С версии: base-4.9.0.0
Подробности экземпляра Определено в Data.Functor.Product Методы (>>=) :: Product f g a -> (a -> Product f g b) -> Product f g b Источник (>>) :: Product f g a -> Product f g b -> Product f g b Источник return :: a -> Product f g a Источник
(Monad f, Monad g) => Monad (f :*: g) Источник	С версии: base-4.9.0.0
Подробности экземпляра Определено в GHC.Internal.Generics Методы (>>=) :: (f :: g) a -> (a -> (f :: g) b) -> (f :: g) b Источник (>>) :: (f :: g) a -> (f :: g) b -> (f :: g) b Источник return :: a -> (f :*: g) a Источник
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) Источник	С версии: base-4.14.0.0
Подробности экземпляра Определено в GHC.Internal.Base Методы (>>=) :: (a, b, c, a0) -> (a0 -> (a, b, c, b0)) -> (a, b, c, b0) Источник (>>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) Источник return :: a0 -> (a, b, c, a0) Источник
Monad ((->) r) Источник	С версии: base-2.1
Подробности экземпляра Определено в GHC.Internal.Base Методы (>>=) :: (r -> a) -> (a -> r -> b) -> r -> b Источник (>>) :: (r -> a) -> (r -> b) -> r -> b Источник return :: a -> r -> a Источник
Monad f => Monad (M1 i c f) Источник	С версии: base-4.9.0.0
Подробности экземпляра Определено в GHC.Internal.Generics Методы (>>=) :: 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 Источник

class Monad m => MonadFail (m :: Type -> Type) where Источник

Если значение связывается в нотации do, шаблон в левой части <- может не совпасть. В этом случае данный класс предоставляет функцию для обработки такой ситуации.

Monad без экземпляра MonadFail можно использовать только с шаблонами, которые всегда совпадают, например с newtype-типами, кортежами, типами данных с единственным конструктором данных и нестрогими шаблонами (~pat).

Экземпляры MonadFail должны удовлетворять следующему закону: fail s должен быть левым нулём для >>=,

fail s >>= f  =  fail s

Если ваш Monad также является MonadPlus, популярным определением будет

fail _ = mzero

fail s должно быть действием, выполняемым в самой монаде, а не исключением (за исключением экземпляров MonadIO). В частности, fail не следует реализовывать через error.

С версии: base-4.9.0.0

Методы

fail :: HasCallStack => String -> m a Источник

Экземпляры

Подробности экземпляров

MonadFail Q Источник
Подробности экземпляра Определён в GHC.Internal.TH.Syntax Методы fail :: HasCallStack => String -> Q a Источник
MonadFail P Источник	С версии: base-4.9.0.0
Подробности экземпляра Определён в GHC.Internal.Text.ParserCombinators.ReadP Методы fail :: HasCallStack => String -> P a Источник
MonadFail ReadP Источник	С версии: base-4.9.0.0
Подробности экземпляра Определён в GHC.Internal.Text.ParserCombinators.ReadP Методы fail :: HasCallStack => String -> ReadP a Источник
MonadFail ReadPrec Источник	С версии: base-4.9.0.0
Подробности экземпляра Определён в GHC.Internal.Text.ParserCombinators.ReadPrec Методы fail :: HasCallStack => String -> ReadPrec a Источник
MonadFail IO Источник	С версии: base-4.9.0.0
Подробности экземпляра Определён в GHC.Internal.Control.Monad.Fail Методы fail :: HasCallStack => String -> IO a Источник
MonadFail Maybe Источник	С версии: base-4.9.0.0
Подробности экземпляра Определён в GHC.Internal.Control.Monad.Fail Методы fail :: HasCallStack => String -> Maybe a Источник
MonadFail [] Источник	С версии: base-4.9.0.0
Подробности экземпляра Определён в GHC.Internal.Control.Monad.Fail Методы fail :: HasCallStack => String -> [a] Источник
MonadFail f => MonadFail (Ap f) Источник	С версии: base-4.12.0.0
Подробности экземпляра Определён в GHC.Internal.Data.Monoid Методы fail :: HasCallStack => String -> Ap f a Источник

class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where Источник

Монады, которые также поддерживают выбор и отказ.

Минимальное полное определение

Nothing

Методы

mzero :: m a Источник

Нейтральный элемент для mplus. Он также должен удовлетворять уравнениям

mzero >>= f  =  mzero
v >> mzero   =  mzero

Определение по умолчанию:

mzero = empty

mplus :: m a -> m a -> m a Источник

Ассоциативная операция. Определение по умолчанию:

mplus = (<|>)

Экземпляры

Подробности экземпляров

MonadPlus STM Источник	Выполняет первое действие `retry`ing `STM`, которое не завершается с ошибкой. Начиная с: base-4.3.0.0
Подробности экземпляра Определён в GHC.Internal.Conc.Sync Методы mzero :: STM a Источник mplus :: STM a -> STM a -> STM a Источник
MonadPlus P Источник	Начиная с: base-2.1
Подробности экземпляра Определён в GHC.Internal.Text.ParserCombinators.ReadP Методы mzero :: P a Источник mplus :: P a -> P a -> P a Источник
MonadPlus ReadP Источник	Начиная с: base-2.1
Подробности экземпляра Определён в GHC.Internal.Text.ParserCombinators.ReadP Методы mzero :: ReadP a Источник mplus :: ReadP a -> ReadP a -> ReadP a Источник
MonadPlus ReadPrec Источник	Начиная с: base-2.1
Подробности экземпляра Определён в GHC.Internal.Text.ParserCombinators.ReadPrec Методы mzero :: ReadPrec a Источник mplus :: ReadPrec a -> ReadPrec a -> ReadPrec a Источник
MonadPlus IO Источник	Возвращает результат первого действия `IO`, не завершающегося исключением. `mzero` выбрасывает исключение. Начиная с: base-4.9.0.0
Подробности экземпляра Определён в GHC.Internal.Base Методы mzero :: IO a Источник mplus :: IO a -> IO a -> IO a Источник
MonadPlus Maybe Источник	Выбирает самое левое значение `Just` или, в качестве альтернативы, `Nothing`. Начиная с: base-2.1
Подробности экземпляра Определён в GHC.Internal.Base Методы mzero :: Maybe a Источник mplus :: Maybe a -> Maybe a -> Maybe a Источник
MonadPlus [] Источник	Объединяет списки конкатенацией, начиная с пустого списка. Начиная с: base-2.1
Подробности экземпляра Определён в GHC.Internal.Base Методы mzero :: [a] Источник mplus :: [a] -> [a] -> [a] Источник
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a) Источник	Начиная с: base-4.6.0.0
Подробности экземпляра Определён в GHC.Internal.Control.Arrow Методы mzero :: ArrowMonad a a0 Источник mplus :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 Источник
MonadPlus (Proxy :: Type -> Type) Источник	Начиная с: base-4.9.0.0
Подробности экземпляра Определён в GHC.Internal.Data.Proxy Методы mzero :: Proxy a Источник mplus :: Proxy a -> Proxy a -> Proxy a Источник
MonadPlus (U1 :: Type -> Type) Источник	Начиная с: base-4.9.0.0
Подробности экземпляра Определён в GHC.Internal.Generics Методы mzero :: U1 a Источник mplus :: U1 a -> U1 a -> U1 a Источник
MonadPlus m => MonadPlus (Kleisli m a) Источник	Начиная с: base-4.14.0.0
Подробности экземпляра Определён в GHC.Internal.Control.Arrow Методы mzero :: Kleisli m a a0 Источник mplus :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 Источник
MonadPlus f => MonadPlus (Ap f) Источник	Начиная с: base-4.12.0.0
Подробности экземпляра Определён в GHC.Internal.Data.Monoid Методы mzero :: Ap f a Источник mplus :: Ap f a -> Ap f a -> Ap f a Источник
MonadPlus f => MonadPlus (Alt f) Источник	Начиная с: base-4.8.0.0
Подробности экземпляра Определён в GHC.Internal.Data.Semigroup.Internal Методы mzero :: Alt f a Источник mplus :: Alt f a -> Alt f a -> Alt f a Источник
MonadPlus f => MonadPlus (Rec1 f) Источник	Начиная с: base-4.9.0.0
Подробности экземпляра Определён в GHC.Internal.Generics Методы mzero :: Rec1 f a Источник mplus :: Rec1 f a -> Rec1 f a -> Rec1 f a Источник
(MonadPlus f, MonadPlus g) => MonadPlus (Product f g) Источник	Начиная с: base-4.9.0.0
Подробности экземпляра Определён в Data.Functor.Product Методы mzero :: Product f g a Источник mplus :: Product f g a -> Product f g a -> Product f g a Источник
(MonadPlus f, MonadPlus g) => MonadPlus (f :*: g) Источник	Начиная с: base-4.9.0.0
Подробности экземпляра Определён в GHC.Internal.Generics Методы mzero :: (f :: g) a Источник mplus :: (f :: g) a -> (f :: g) a -> (f :: g) a Источник
MonadPlus f => MonadPlus (M1 i c f) Источник	Начиная с: base-4.9.0.0
Подробности экземпляра Определён в GHC.Internal.Generics Методы mzero :: M1 i c f a Источник mplus :: M1 i c f a -> M1 i c f a -> M1 i c f a Источник

Функции

Соглашения об именовании

Функции этого модуля используют следующие соглашения об именовании:

Постфикс 'M' всегда обозначает функцию в категории Клейсли: конструктор типа монады m добавляется к результатам функции (с учётом каррирования) и нигде больше. Например:

filter  ::              (a ->   Bool) -> [a] ->   [a]
filterM :: (Monad m) => (a -> m Bool) -> [a] -> m [a]

Постфикс '_' изменяет тип результата с (m a) на (m ()). Например:

sequence  :: Monad m => [m a] -> m [a]
sequence_ :: Monad m => [m a] -> m ()

Префикс 'm' обобщает существующую функцию до монадической формы. Например:

filter  ::                (a -> Bool) -> [a] -> [a]
mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a

mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b) Источник

Преобразует каждый элемент структуры в монадическое действие, выполняет эти действия слева направо и собирает результаты. Версию, игнорирующую результаты, см. в mapM_.

Примеры

Развернуть

mapM — это буквально traverse с сигнатурой типа, ограниченной до Monad. Благодаря дополнительным возможностям Monad его реализация может быть эффективнее.

mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m () Источник

Преобразует каждый элемент структуры в монадическое действие, выполняет эти действия слева направо и игнорирует результаты. Версию, которая не игнорирует результаты, см. в mapM.

mapM_ похожа на traverse_, но специализирована для монадических действий.

forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b) Источник

forM — это mapM с переставленными аргументами. Версию, игнорирующую результаты, см. в forM_.

forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m () Источник

forM_ — это mapM_ с переставленными аргументами. Версию, которая не игнорирует результаты, см. в forM.

forM_ похожа на for_, но специализирована для монадических действий.

sequence :: (Traversable t, Monad m) => t (m a) -> m (t a) Источник

Выполняет каждое монадическое действие в структуре слева направо и собирает результаты. Версию, игнорирующую результаты, см. в sequence_.

Примеры

Развернуть

Базовое использование:

В первых двух примерах вход и выход sequence изоморфны.

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

Следующие примеры демонстрируют поведение с коротким замыканием для 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 () Исходный код

Выполняет каждое монадическое действие в структуре слева направо и игнорирует результаты. Версию, которая не игнорирует результаты, см. в sequence.

sequence_ работает так же, как sequenceA_, но специализирована для монадических действий.

(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 Исходный код

То же, что и >>=, но аргументы переставлены местами.

as >>= f == f =<< as

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 Исходный код

Композиция стрелок Kleisli слева направо.

'(bs >=> cs) a' можно понимать как выражение do

do b <- bs a
   cs b

или в терминах (>>=) как

bs a >>= cs

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c infixr 1 Исходный код

Композиция стрелок Клейсли справа налево. (>=>), аргументы переставлены местами.

Обратите внимание, что этот оператор похож на композицию функций (.):

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

forever :: Applicative f => f a -> f b Исходный код

Повторяет действие бесконечно.

Примеры

Развернуть

Часто forever используют для обработки входных данных из сетевых сокетов, Handle и каналов (например, MVar и Chan).

Например, вот как можно реализовать эхо-сервер, используя forever и для прослушивания подключений клиентов через сетевой сокет, и для отправки клиентского ввода обратно через дескрипторы подключений:

echoServer :: Socket -> IO ()
echoServer socket = forever $ do
  client <- accept socket
  forkFinally (echo client) (\_ -> hClose client)
  where
    echo :: Handle -> IO ()
    echo client = forever $
      hGetLine client >>= hPutStrLn client

Обратите внимание, что «forever» не обязательно означает бесконечное выполнение. Если действие выполняется в MonadPlus и прерывается после некоторого числа итераций, то forever фактически возвращает mzero, тем самым прерывая выполнение вызывающего кода.

void :: Functor f => f a -> f () Исходный код

void value отбрасывает или игнорирует результат вычисления, например возвращаемое значение действия IO.

Примеры

Развернуть

Заменить содержимое Maybe Int на unit:

>>> void Nothing
Nothing

>>> void (Just 3)
Just ()

Заменить содержимое Either Int Int на unit, получив Either Int ():

>>> void (Left 8675309)
Left 8675309

>>> void (Right 8675309)
Right ()

Заменить каждый элемент списка на unit:

>>> void [1,2,3]
[(),(),()]

Заменить второй элемент пары на unit:

>>> void (1,2)
(1,())

Отбросить результат действия IO:

>>> mapM print [1,2]
1
2
[(),()]

>>> void $ mapM print [1,2]
1
2

Обобщения функций для списков

join :: Monad m => m (m a) -> m a Исходный код

Функция join — общепринятый оператор соединения монад. Он используется для удаления одного уровня монадической структуры, перенося связанный аргумент на внешний уровень.

'join bss' можно понимать как выражение do

do bs <- bss
   bs

Примеры

Развернуть

>>> join [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
[1,2,3,4,5,6,7,8,9]

>>> join (Just (Just 3))
Just 3

Часто join используют для запуска вычисления IO, возвращённого транзакцией STM, поскольку транзакции STM не могут напрямую выполнять IO. Напомним, что

atomically :: STM a -> IO a

используется для атомарного выполнения транзакций STM. Поэтому, специализировав типы atomically и join до

atomically :: STM (IO b) -> IO (IO b)
join       :: IO (IO b)  -> IO b

мы можем объединить их следующим образом:

join . atomically :: STM (IO b) -> IO b

чтобы выполнить транзакцию STM и возвращённое ею действие IO.

msum :: (Foldable t, MonadPlus m) => t (m a) -> m a Исходный код

Сумма набора действий с использованием (<|>), обобщающая concat.

msum работает так же, как asum, но специализирована для MonadPlus.

Примеры

Развернуть

Базовое использование с экземпляром MonadPlus для Maybe:

>>> msum [Just "Hello", Nothing, Just "World"]
Just "Hello"

mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a Исходный код

Прямой эквивалент MonadPlus для filter.

Примеры

Развернуть

Функция filter — это просто mfilter, специализированная для монады списков:

filter = ( mfilter :: (a -> Bool) -> [a] -> [a] )

Пример использования mfilter с монадой Maybe:

>>> mfilter odd (Just 1)
Just 1
>>> mfilter odd (Just 2)
Nothing

filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] Исходный код

Это обобщение функции filter, основанной на списках.

runIdentity (filterM (Identity . p) xs) == filter p xs

Примеры

Развернуть

>>> filterM (\x -> do
      putStrLn ("Keep: " ++ show x ++ "?")
      answer <- getLine
      pure (answer == "y"))
    [1, 2, 3]
Keep: 1?
y
Keep: 2?
n
Keep: 3?
y
[1,3]

>>> filterM (\x -> do
      putStr (show x)
      x' <- readLn
      pure (x == x'))
    [1, 2, 3]
12
22
33
[2,3]

mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) Исходный код

Функция mapAndUnzipM применяет свой первый аргумент к элементам списка и возвращает результат в виде пары списков. Эта функция в основном используется со сложными структурами данных или монадами состояния.

zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] Исходный код

Функция zipWithM обобщает zipWith для произвольных аппликативных функторов.

zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () Исходный код

zipWithM_ — это расширение zipWithM, которое игнорирует итоговый результат.

foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b Исходный код

Функция foldM аналогична foldl, за исключением того, что её результат заключён в монаду. Обратите внимание, что foldM обрабатывает аргументы списка слева направо. Это может стать проблемой, если (>>) и «свёртываемая функция» не коммутативны.

foldM f a1 [x1, x2, ..., xm]

==

do
  a2 <- f a1 x1
  a3 <- f a2 x2
  ...
  f am xm

Если требуется вычисление справа налево, входной список следует развернуть.

Примечание: foldM — то же самое, что и foldlM

foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m () Исходный код

Как foldM, но отбрасывает результат.

replicateM :: Applicative m => Int -> m a -> m [a] Исходный код

replicateM n act выполняет действие act n раз, а затем возвращает список результатов.

replicateM n (pure x) == replicate n x

Примеры

Развернуть

>>> replicateM 3 getLine
hi
heya
hiya
["hi","heya","hiya"]

>>> import Control.Monad.State
>>> runState (replicateM 3 $ state $ \s -> (s, s + 1)) 1
([1,2,3],4)

replicateM_ :: Applicative m => Int -> m a -> m () Исходный код

Как replicateM, но отбрасывает результат.

Примеры

Развернуть

>>> replicateM_ 3 (putStr "a")
aaa

Условное выполнение монадических выражений

guard :: Alternative f => Bool -> f () Исходный код

Условный отказ вычислений Alternative. Определяется так:

guard True  = pure ()
guard False = empty

Примеры

Развернуть

Часто guard используют для условной передачи ошибки в монаде ошибок и условного отклонения текущего выбора в парсере на основе Alternative.

В качестве примера передачи ошибки в монаде ошибок Maybe рассмотрим безопасную функцию деления safeDiv x y, которая возвращает Nothing, если знаменатель y равен нулю, и Just (x `div` y) в противном случае. Например:

>>> safeDiv 4 0
Nothing

>>> safeDiv 4 2
Just 2

Определение safeDiv с использованием охранных выражений, но без guard:

safeDiv :: Int -> Int -> Maybe Int
safeDiv x y | y /= 0    = Just (x `div` y)
            | otherwise = Nothing

Определение safeDiv с использованием guard и Monad в записи do:

safeDiv :: Int -> Int -> Maybe Int
safeDiv x y = do
  guard (y /= 0)
  return (x `div` y)

when :: Applicative f => Bool -> f () -> f () Исходный код

Условное выполнение выражений Applicative. Например,

Примеры

Развернуть

when debug (putStrLn "Debugging")

выведет строку Debugging, если булево значение debug равно True, и ничего не сделает в противном случае.

>>> putStr "pi:" >> when False (print 3.14159)
pi:

unless :: Applicative f => Bool -> f () -> f () Исходный код

Противоположность when.

Примеры

Развернуть

>>> do x <- getLine
       unless (x == "hi") (putStrLn "hi!")
comingupwithexamplesisdifficult
hi!

>>> unless (pi > exp 1) Nothing
Just ()

Операторы монадического подъёма

liftM :: Monad m => (a1 -> r) -> m a1 -> m r Исходный код

Поднимает функцию в монаду. Эквивалентно fmap, но специализировано для монад.

liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r Исходный код

Поднимает функцию в монаду, обрабатывая монадические аргументы слева направо.

Примеры

Развернуть

>>> liftM2 (+) [0,1] [0,2]
[0,2,1,3]

>>> liftM2 (+) (Just 1) Nothing
Nothing

>>> liftM2 (+) (+ 3) (* 2) 5
18

liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r Исходный код

Поднимает функцию в монаду, обрабатывая монадические аргументы слева направо (ср. liftM2).

liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r Исходный код

Поднимает функцию в монаду, обрабатывая монадические аргументы слева направо (ср. liftM2).

liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r Исходный код

Поднимает функцию в монаду, обрабатывая монадические аргументы слева направо (ср. liftM2).

ap :: Monad m => m (a -> b) -> m a -> m b Исходный код

Во многих случаях операции liftM можно заменить на ap, который поднимает применение функции.

return f `ap` x1 `ap` ... `ap` xn

эквивалентно

liftM<n> f x1 x2 ... xn

Примеры

Развернуть

>>> pure (\x y z -> x + y * z) `ap` Just 1 `ap` Just 5 `ap` Just 10
Just 51

Строгие монадические функции

(<$!>) :: Monad m => (a -> b) -> m a -> m b infixl 4 Исходный код

Строгая версия <$>.

Начиная с: base-4.8.0.0

© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/9.14.1/docs/libraries/base-4.22.0.0-66f8/Control-Monad.html