Control.Monad

class Functor f where Источник

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

Тождество

fmap id == id

Композиция

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

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

do a <- as
   pure (f a)

do bs
   pure a

class Applicative m => Monad m 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 для списков, Maybe и IO , определённых в Prelude, удовлетворяют этим законам.

do a <- as
   bs a

do as
   bs

class Monad m => MonadFail m where Исходный код

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

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

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

fail s >>= f  =  fail s

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

fail _ = mzero

С момента: base-4.9.0.0

class (Alternative m, Monad m) => MonadPlus m where Исходный код

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

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

mzero = empty

mplus = (<|>)

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

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

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) Source

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

mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m () Source

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

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

forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b) Source

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

forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m () Source

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

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

sequence :: (Traversable t, Monad m) => t (m a) -> m (t a) Source

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

sequence_ :: (Foldable t, Monad m) => t (m a) -> m () Source

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

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

(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 Source

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

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 Source

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

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

do b <- bs a
   cs b

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c infixr 1 Source

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

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

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

forever :: Applicative f => f a -> f b Source

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

Используя ApplicativeDo: 'forever as' можно интерпретировать как псевдо-do выражение

do as
   as
   ..

с as повторением.

Примеры

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

void :: Functor f => f a -> f () Source

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

Используя ApplicativeDo: 'void as' можно интерпретировать как выражение do

do as
   pure ()

с выведенным Functor ограничением.

Примеры

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

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

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

do bs <- bss
   bs

Примеры

atomically :: STM a -> IO a

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

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

msum :: (Foldable t, MonadPlus m) => t (m a) -> m a Source

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

mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a Source

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

Примеры

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

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

filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] Source

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

mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) Source

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

zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] Source

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

zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () Source

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

foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b Source

Функция 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 () Source

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

replicateM :: Applicative m => Int -> m a -> m [a] Source

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

Используя ApplicativeDo: 'replicateM 5 as' можно понимать как выражение do

do a1 <- as
   a2 <- as
   a3 <- as
   a4 <- as
   a5 <- as
   pure [a1,a2,a3,a4,a5]

Обратите внимание на ограничение Applicative.

replicateM_ :: Applicative m => Int -> m a -> m () Source

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

guard :: Alternative f => Bool -> f () Source

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

guard True  = pure ()
guard False = empty

Примеры

>>> safeDiv 4 0
Nothing
>>> safeDiv 4 2
Just 2

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

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

when :: Applicative f => Bool -> f () -> f () Source

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

when debug (putStrLn "Debugging")

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

unless :: Applicative f => Bool -> f () -> f () Source

Обратная функция к when.

liftM :: Monad m => (a1 -> r) -> m a1 -> m r Source

Поднятие функции в монаду.

liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r Source

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

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 Source

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

liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r Source

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

liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r Source

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

ap :: Monad m => m (a -> b) -> m a -> m b Source

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

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

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

liftMn f x1 x2 ... xn

(<$!>) :: Monad m => (a -> b) -> m a -> m b infixl 4 Source

Жесткая версия <$>.

С версии: base-4.8.0.0