存在类型和单子转换器

Question

上下文：我试图生成一个错误单子，它还跟踪警告列表，如下所示：

data Dangerous a = forall e w. (Error e, Show e, Show w) =>
    Dangerous (ErrorT e (State [w]) a)

即 Dangerous a 是一个导致 (Either ea, [w] ) 其中 e 是可显示的错误，w 是可显示的。

问题是，我似乎无法实际运行这个东西，主要是因为我不太了解存在类型。观察：

runDangerous :: forall a e w. (Error e, Show e, Show w) =>
    Dangerous a -> (Either e a, [w])
runDangerous (Dangerous f) = runState (runErrorT f) []

这不会编译，因为：

Could not deduce (w1 ~ w)
from the context (Error e, Show e, Show w)
...
`w1' is a rigidtype variable bound by
    a pattern with constructor
    Dangerous :: forall a e w.
                 (Error e, Show e, Show w) =>
                 ErrorT e (State [w]) a -> Dangerous a
...
`w' is a rigid type variable bound by
    the type signature for
    runDangerous :: (Error e, Show e, Show w) =>
                    Dangerous a -> (Either e a, [w])

我迷路了。 w1是什么？为什么我们不能推断出它是~w？

Answer 1

存在主义可能不是你想要的。无法“观察”Dangerous a 值中绑定到 e 或 w 的实际类型，因此您完全受限于Error 和 Show 为您提供的操作。

换句话说，您对 w 唯一了解的是您可以将其转换为 String，因此它也可能只是一个 String > （为了简化而忽略优先级），而您对 e 唯一了解的是，您可以将其转换为 String，您可以将 String code>s 进去，你就拥有了它的独特价值（noMsg）。无法断言或检查这些类型是否与其他类型相同，因此一旦将它们放入Dangerous中，就无法恢复这些类型可能具有的任何特殊结构。

错误消息的意思是，本质上，您的 runDangerous 类型声称您可以将 Dangerous 转换为 (Either ea, [w])< /code> 对于具有相关实例的任何 e 和 w。这显然是不正确的：您只能将 Dangerous 转换为该类型，一个选择 e 和 w >：它是用它创建的。 w1 只是因为你的 Dangerous 类型是用类型变量 w 定义的，runDangerous 也是如此，所以GHC 重命名了其中之一以避免名称冲突。

您需要为 runDangerous 提供的类型如下所示：

runDangerous
  :: (forall e w. (Error e, Show e, Show w) => (Either e a, [w]) -> r)
  -> Dangerous a -> r

给定一个函数，该函数将接受 (Either ea, [w]) 类型的值 any 选择e 和w，只要它们有给定的实例，并且Dangerous a 会产生该函数的结果。这很难让你头脑清醒！

实现非常简单，

runDangerous f (Dangerous m) = f $ runState (runErrorT m) []

只需对您的版本进行微不足道的更改即可。如果这对你有用，那就太好了；但我怀疑存在主义是否是实现你想做的事情的正确方法。

请注意，您需要使用 {-# LANGUAGE RankNTypes #-} 来表示 runDangerous 的类型。或者，您可以为您的结果类型定义另一个存在式：

data DangerousResult a = forall e w. (Error e, Show e, Show w) =>
   DangerousResult (Either e a, [w])

runDangerous :: Dangerous a -> DangerousResult a
runDangerous (Dangerous m) = DangerousResult $ runState (runErrorT m) []

并使用 case 提取结果，但您必须小心，否则 GHC 会开始抱怨您已经让 e< /code> 或 w escape — 这相当于尝试将不充分多态的函数传递给其他形式的 runDangerous；即需要对 e 和 w 进行更多限制，超出了 runDangerous 类型所保证的范围。

Answer 2

好吧，我想我明白了我在困惑之后的情况：（

data Failure = forall e. (Error e, Show e) => Failure e

data Warning = forall w. (Show w) => Warning w

class (Monad m) => Errorable m where
    warn :: (Show w) => w -> m ()
    throw :: (Error e, Show e) => e -> m ()

instance Errorable Dangerous where
    warn w = Dangerous (Right (), [Warning w])
    throw e = Dangerous (Left $ Failure e, [])

instance Monad Dangerous 和 data DangerousT 也有帮助。）

这允许您拥有以下代码：

foo :: Dangerous Int
foo = do
    when (badThings) (warn $ BadThings with some context)
    when (worseThings) (throw $ BarError with other context)

data FooWarning = BadThings FilePath Int String
instance Show FooWarning where
...

然后在您可以在主模块中定义 Show Failure、Error Failure 和 Show warning 的自定义实例，并采用集中方式来格式化错误消息，例如

instance Show Warning where show (Warning s) = "WARNING: " ++ show s
instance Show Failure where ...

let (result, warnings) = runDangerous function
in ...

，在我看来，这是一个漂亮的处理错误和警告的酷方法。我有一个类似这样的工作模块，现在我要完善它，也许把它放在 hackage 上。建议表示赞赏。