Question

我正在尝试设计嵌入式语言，其中操作可以根据值提升某些标志。我预见到对标量值和向量（例如map，fold等）的操作。我的想法是使用Writer Monad来跟踪标志。简化示例，其中实际类型为“Int”，如果任何参数为0，则引发标志。

import Control.Monad.Identity
import Control.Monad.Writer
import Data.Monoid    

type WInt = Writer Any Int

bplus :: Int -> Int -> WInt
bplus a b =
    do
      tell (Any (a == 0 || b == 0)) ;
           return (a+b)

wbplus :: WInt -> WInt -> WInt
wbplus wa wb =
    do
      a <- wa ;
      b <- wb ;
      tell (Any (a == 0 || b == 0)) ;
           return (a+b)

ex0 = runWriter (bplus 1 2) 
ex1 = runWriter (bplus 0 2)

ex2 = runWriter (wbplus (return 1) (return 2))
ex3 = runWriter (wbplus (return 0) (return 2))

ex4 = runWriter (wbplus (wbplus (return 1) (return 2)) (return 2))
ex5 = runWriter (wbplus (wbplus (return 0) (return 2)) (return 2))
ex6 = runWriter (wbplus (wbplus (return 1) (return 2)) (return 0))

我不确定实现这个的最佳方法是什么。一些问题：

我应该像bplus那样定义所有操作，还是像wbplus那样定义。看来，Laters使构图更容易。但是使用foldM二元运算符应该具有类型Int -> Int -> WInt。
列表的适当类型是什么：Writer Any [Int]或[Wint]？

感谢任何建议或想法。

Answer 1

您可以使用适当的monadic操作从bplus派生wbplus，反之亦然：

import Control.Monad

apM2 :: Monad m => (a -> b -> m c) -> m a -> m b -> m c
apM2 f ma mb = do
  a <- ma
  b <- mb
  f a b

pureM2 :: Monad m => (m a -> m b -> m c) -> a -> b -> m c
pureM2 f a b = f (return a) (return b)

他们彼此相反，从他们作品的类型签名中可以看出：

ghci> :t pureM2 . apM2
pureM2 . apM2 :: Monad m => (a -> b -> m c) -> a -> b -> m c

ghci> :t apM2 . pureM2
apM2 . pureM2 :: Monad m => (m a -> m b -> m c) -> m a -> m b -> m c

现在您可以定义wbplus = apM2 bplus或bplus = pureM2 wbplus。没有明确的答案，哪一个更好，用你的品味和判断力。 TemplateHaskell采用wbplus方法，并定义了与Q monad中的值一起使用的所有操作。请参阅Language.Haskell.TH.Lib。

关于[m a] vs m [a]，您只能朝一个方向（通过sequence :: Monad m => [m a] -> m [a]）。你想过相反的方向吗？您是否关心具有自己标志的单个值？或者您是否愿意使用标记将计算整体注释？

真正的问题是，你的心理模型是什么？但是，让我们考虑每种设计选择的一些后果。

如果您选择将每个值表示为Writer Any a并让所有操作都可以使用，那么您可以从newtype开始：

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

import Control.Monad.Writer

newtype Value a = Value (Writer Any a)
  deriving (Functor, Applicative, Monad)

现在您可以为您定义标准类型类的实例值：

instance (Num a, Eq a) => Num (Value a) where
  va + vb = do
    a <- va
    b <- vb
    (Value . tell . Any) (b == 0 || a == 0)
    return (a + b)
  (*) = liftM2 (*)
  abs = fmap abs
  signum = fmap signum
  negate = fmap negate
  fromInteger = return . fromInteger

  instance Monoid a => Monoid (Value a) where
    mempty = pure mempty
    mappend = liftM2 mappend

对于EDSL，这提供了一个巨大的优势：来自编译器的简洁性和语法支持。您现在可以写getValue (42 + 0)而不是wbplus (pure 42) (pure 0)。

相反，如果您没有将旗帜视为价值观的一部分，而是将其视为外部影响，那么选择其他方法会更好。但是，不要写Writer Any [Int]之类的内容，而是使用mtl中的相应类：MonadWriter Any m => m [Int]。这样，如果您以后发现需要使用其他效果，则可以轻松地将它们添加到某些（但不是全部）操作中。例如，您可能希望在除以零时引发错误：
```
  data DivisionByZero = DivisionByZero

  divZ :: (MonadError DivisionByZero m, Fractional a, Eq a) => a -> a -> m a
  divZ a b
    | b == 0 = throwError DivisionByZero
    | otherwise = pure (a / b)

  plusF :: (MonadWriter Any m, Num a, Eq a) => a -> a -> m a
  plusF a b = do
    tell (Any (b == 0 || a == 0))
    return (a + b)
```
现在，您可以在一个monad中使用plusF和divZ，尽管它们具有不同的效果。如果您以后发现自己需要与某些外部库集成，那么这种灵活性就会派上用场。

现在，我没有太多考虑，但也许你可以使用像newtype Value m a = Value { getValue :: m a }之类的东西来结合这些方法。祝你探索设计空间：）

Haskell写Monad表达式

1 个答案: