1

我正在尝试设计嵌入式语言，其中操作可以根据值引发某些标志。我预见到对标量值以及向量（例如映射、折叠等）的操作。我的想法是使用 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))

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

  1. 我应该像 for 一样定义所有操作bplus吗wbplus？看起来，Latters 让作曲变得更容易了。但是要使用foldM二元运算符应该有类型Int -> Int -> WInt。

  2. 列表的合适类型是什么：Writer Any [Int]或[Wint]？

任何建议或想法表示赞赏。

4

1 回答 1

1

您可以使用适当的一元操作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方法并定义了所有操作以使用Qmonad 中的值。请参阅Language.Haskell.TH.Lib。

关于[m a]vs m [a]，您只能朝一个方向前进（通过sequence :: Monad m => [m a] -> m [a]）。你会想朝相反的方向走吗？您是否关心具有自己标志的各个值，还是更愿意用标志对整个计算进行注释？

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

  1. 如果您选择将每个值表示为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).

  2. 相反，如果您不将标志视为您的价值观的一部分，而是将它们视为外部影响，那么最好采用替代方法。但与其编写类似的东西，不如使用来自:的Writer Any [Int]相应类。这样，如果您以后发现需要使用其他效果，您可以轻松地将它们添加到一些（但不是全部）操作中。例如，您可能希望在除以零的情况下引发错误：mtlMonadWriter 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 中一起使用plusFand divZ，尽管它们有不同的效果。如果您以后发现自己需要与一些外部库集成，这种灵活性将派上用场。

现在，我没有考虑太多，但也许您可以使用类似newtype Value m a = Value { getValue :: m a }. 祝探索设计空间好运:)

于 2016-03-23T12:58:16.240 回答