6.2.4. Применение do-нотации

ApplicativeDo

Since:

8.0.1

Разрешает использование Applicative do нотации.

Опция языка ApplicativeDo включает альтернативный перевод для do-нотации, который использует операторы <$>, <*>, а также join по возможности. Есть две основные причины для этого:

• Мы можем использовать do-нотацию с типами, которые являются экземплярами Applicative и Functor, но не Monad
• В некоторых монадах использование аппликативных операторов более эффективно, чем монадическое связывание. Например, это может позволить большее параллелизма.

Преобразование аппликативной do-нотации сохраняет исходную семантику, при условии, что экземпляр Applicative удовлетворяет условиям <*> = ap и pure = return (что верно для всех распространённых монадических типов). Таким образом, вы обычно можете включить ApplicativeDo без опасений за нарушение работы вашей программы. Есть одна потенциальная проблема, о которой нужно помнить; см. Важные моменты.

С ApplicativeDo нет синтаксических изменений. Единственный способ, которым это проявляется на уровне исходного кода, состоит в том, что у вас может быть выражение do , которое не требует ограничения Monad. Например, в GHCi:

Prelude> :set -XApplicativeDo
Prelude> :t \m -> do { x <- m; return (not x) }
\m -> do { x <- m; return (not x) }
  :: Functor f => f Bool -> f Bool

Этот пример требует только Functor, потому что он переводится в (\x -> not x) <$> m. Более сложный пример требует Applicative,

Prelude> :t \m -> do { x <- m 'a'; y <- m 'b'; return (x || y) }
\m -> do { x <- m 'a'; y <- m 'b'; return (x || y) }
  :: Applicative f => (Char -> f Bool) -> f Bool

Здесь GHC перевёл выражение в

(\x y -> x || y) <$> m 'a' <*> m 'b'

Можно увидеть фактический перевод, используя -ddump-ds, но будьте осторожны, вывод довольно объёмный.

Обратите внимание, что если выражение не может быть переведено с использованием только <$>, <*>, то оно понесёт ограничение Monad как обычно. Это происходит, когда есть зависимость от значения, произведённого предыдущим оператором в блоке do:

Prelude> :t \m -> do { x <- m True; y <- m x; return (x || y) }
\m -> do { x <- m True; y <- m x; return (x || y) }
  :: Monad m => (Bool -> m Bool) -> m Bool

Здесь m x зависит от значения x, произведённого первым оператором, поэтому выражение не может быть переведено с использованием <*>.

В общем случае правило, когда оператор do влечёт за собой ограничение Monad следующее. Если выражение do имеет следующий вид:

do p1 <- E1; ...; pn <- En; return E

где ни одна из переменных, определённых p1...pn, не упоминается в E1...En, и p1...pn — это все переменные или ленивые шаблоны, то выражение будет требовать только Applicative. Выражение do также может содержать операторы let в любом месте, при условии, что правые части let привязок не упоминают ни одну из p1...pn. В противном случае выражение будет требовать Monad. Блок может возвращать чистое выражение E в зависимости от результатов p1...pn и let привязок, с использованием return или pure.

Примечание: последний оператор должен точно соответствовать одному из этих шаблонов:

• return E
• return $ E
• pure E
• pure $ E

иначе GHC не может распознать его как оператор return, и преобразование для использования <$>, которое мы видели выше, не применяется. В частности, незначительные вариации, такие как return . Just $ x или let x = e in return x, не будут распознаны.

Если последний оператор не соответствует ни одному из этих форм, GHC возвращается к стандартному преобразованию do и выражение потребует ограничения Monad.

Когда операторы в выражении do имеют зависимости друг от друга, и ApplicativeDo не может вывести тип Applicative, он использует эвристический алгоритм, чтобы попытаться использовать <*> по возможности. Этот алгоритм обычно находит наилучшее решение, но в редких сложных случаях может пропустить возможность. Есть алгоритм, который находит оптимальное решение, предоставляемый в виде опции:

-foptimal-applicative-do

Since:

8.0.1

Включает альтернативный алгоритм для выбора того, где использовать <*> в сочетании с расширением языка ApplicativeDo. Этот алгоритм всегда находит оптимальное решение, но он затратный: O(n^3), поэтому эта опция может привести к длинным временам компиляции при наличии очень больших выражений do (более 100 операторов). По умолчанию алгоритм ApplicativeDo — это O(n^2).

> :t \m -> do { (x:xs) <- m; return x }
\m -> do { (x:xs) <- m; return x } :: Monad m => m [b] -> m b

> :t \m -> do { ~(x:xs) <- m; return x }
\m -> do { ~(x:xs) <- m; return x } :: Functor f => f [b] -> f b

instance Functor MyType where
    fmap f m = do x <- m; return (f x)

instance Functor MyType where
    fmap f m = fmap (\x -> f x) m

instance Applicative MyType where
    pure = return
    x <*> y = do f <- x; a <- y; return (f a)

instance Functor MyType where
    fmap f m = m >>= return . f

instance Applicative MyType where
    pure = return
    (<*>) = ap