Control.Monad

Классы Functor и monad

class Functor f where Source

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

fmap id  ==  id
fmap (f . g)  ==  fmap f . fmap g

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

class Applicative m => Monad m where Source

Класс 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

• (<*>) = ap

Вышеуказанные законы подразумевают:

• fmap f xs  =  xs >>= return . f

• (>>) = (*>)

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

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

class (Alternative m, Монад m) => МонадПлюс m where Источник

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

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

Функции

Правила именования

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

• Суффикс 'M' всегда обозначает функцию в категории Kleisli: конструктор типа монады 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' обобщает существующую функцию до монадической формы. Например:

 sum  :: Num a       => [a]   -> a
 msum :: MonadPlus m => [m a] -> m a

Основные Monad функции

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

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

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

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

Начиная с версии base 4.8.0.0, mapM_ просто traverse_, специализированная для Monad.

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

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

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

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

Начиная с версии base 4.8.0.0, forM_ просто for_, специализированная для Monad.

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

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

sequence_ :: (Foldable t, Монад m) => t (m a) -> m () Источник

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

Начиная с версии base 4.8.0.0, sequence_ просто sequenceA_, специализированная для Monad.

(=<<) :: Монад m => (a -> m b) -> m a -> m b infixr 1 Источник

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

(>=>) :: Монад m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 Источник

Слева направо композиция Kleisli монады.

(<=<) :: Монад m => (b -> m c) -> (a -> m b) -> a -> m c infixr 1 Источник

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

forever :: Монад m => m a -> m b Источник

forever act повторяет действие бесконечно.

void :: Functor f => f a -> f () Источник

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

Примеры

>>> void Nothing
Nothing
>>> void (Just 3)
Just ()

>>> void (Left 8675309)
Left 8675309
>>> void (Right 8675309)
Right ()

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

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

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

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

join :: Monad m => m (m a) -> m a Источник

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

msum :: (Foldable t, MonadPlus m) => t (m a) -> m a Источник

Сумма коллекции действий, обобщающая concat. Начиная с версии base 4.8.0.0, msum это просто asum, специализированная для MonadPlus.

mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a Источник

Прямой аналог MonadPlus функции filter filter = (mfilter:: (a -> Bool) -> [a] -> [a], применимый к любой MonadPlus, например, mfilter odd (Just 1) == Just 1 mfilter odd (Just 2) == Nothing

filterM :: Monad m => (a -> m Bool) -> [a] -> m [a] Источник

Это обобщает функцию filter для списков.

mapAndUnzipM :: Monad m => (a -> m (b, c)) -> [a] -> m ([b], [c]) Источник

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

zipWithM :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m [c] Источник

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

zipWithM_ :: Monad 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 :: Monad m => Int -> m a -> m [a] Источник

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

replicateM_ :: Monad m => Int -> m a -> m () Источник

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

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

guard :: Alternative f => Bool -> f () Источник

guard b — это pure (), если b — True, и empty , если b — False.

when :: Applicative f => Bool -> f () -> f () Источник

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

when debug (putStrLn "Debugging")

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

unless :: Applicative f => Bool -> f () -> f () Источник

Обратное when.

Операторы подъёма монады

liftM :: Monad m => (a1 -> r) -> m a1 -> m r Источник

Преобразование функции в монаду.

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

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

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

      liftMn f x1 x2 ... xn

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

(<$!>) :: Monad m => (a -> b) -> m a -> m b infixl 4 Источник

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

С версии: 4.8.0.0