存在类型类与数据构造函数与副产品

Question

我发现自己在我的设计中遇到了相同的模式，我开始使用带有一些数据构造函数的类型，最终希望能够对这些数据构造函数进行类型化，从而将它们拆分为自己的类型，然后必须增加程序的其他部分的详细程度需要使用Either或另一个tagged-union，以便我仍然需要表示这些类型的多个（即集合）。

我希望有人能指出我更好的方式来完成我想要做的事情。 让我从一个简单的例子开始。 我正在为测试系统建模，您可以在其中拥有最终以测试结束的嵌套测试套件。 所以，像这样：

data Node =
    Test { source::string }
    Suite { title::string, children::[Node] }

所以，到目前为止，非常简单，基本上是一个花哨的Tree / Leaf声明。 但是，我很快意识到我希望能够制作专门测试的功能。 因此，我现在将它拆分为：

data Test = Test { source::string }
data Suite = Suite { title::string, children::[Either Test Suite] }

或者，我可能会推出一个“自定义”Either（特别是如果示例更复杂，并且有两个以上的选项），比如说：

data Node =
   fromTest Test
   fromSuite Suite

所以，非常不幸的是，为了能够拥有一个可以组合套件或测试的Suite ，我最终得到一个奇怪的开销Either类（无论是实际的Either还是自定义的）。 如果我使用存在类型类，我可以让Test和Suite派生“Node_”然后让Suite拥有所述Node的列表。 副产品将允许类似的东西，我基本上做同样的Either策略没有标签的详细程度。

现在让我通过一个更复杂的例子展开。 测试结果可以是Skipped（测试已禁用），Success，Failure或Omitted（由于先前的故障，测试或套件无法运行）。 同样，我最初开始时是这样的：

data Result = Success | Omitted | Failure | Skipped
data ResultTree =
    Tree { children::[ResultTree], result::Result } |
    Leaf Result

但我很快意识到我希望能够编写具有特定结果的函数，更重要的是，让类型本身强制执行所有权属性：成功的套件必须只拥有Success或Skipped子级，Failure的子级可以是任何东西，只能省略自己省略等等所以现在我最终得到这样的东西：

data Success = Success { children::[Either Success Skipped] }
data Failure = Failure { children::[AnyResult] }
data Omitted = Omitted { children::[Omitted] }
data Skipped = Skipped { children::[Skipped] }
data AnyResult =
  fromSuccess Success |
  fromFailure Failure |
  fromOmitted Omitted |
  fromSkipped Skipped

同样，我现在拥有像AnyResult这样奇怪的“Wrapper”类型，但是，我得到的类型强制执行过去只能从运行时操作强制执行。 是否有一个更好的策略，不涉及打开存在类型类等功能？

Answer 1

我第一眼想到你的句子：“我很快就意识到我希望能够编写具有特定结果的函数”是精化类型 。

它们只允许从类型中取一些值作为输入，并使这些约束编译时检查/错误。

这个来自HaskellX 2018的演讲的视频介绍了LiquidHaskell，它允许在Haskell中使用Refinement Types：

https://skillsmatter.com/skillscasts/11068-keynote-looking-forward-to-niki-vazou-s-keynote-at-haskellx-2018

你必须装饰你的haskell功能签名，并安装LiquidHaskell：

f :: Int -> i : Int {i | i < 3} -> Int f :: Int -> i : Int {i | i < 3} -> Int将是一个函数，它只能接受一个值< 3的Int作为第二个参数，在编译时检查。

您也可以在Result类型上设置约束。

Answer 2

我想你可能寻找的是GADTs与DataKinds 。 这使您可以将数据类型中每个构造函数的类型细化为一组特定的可能值。 例如：

data TestType = Test | Suite

data Node (t :: TestType) where
  TestNode :: { source :: String } -> Node 'Test
  SuiteNode :: { title :: String, children :: [SomeNode] } -> Node 'Suite

data SomeNode where
  SomeNode :: Node t -> SomeNode

然后，当一个函数仅在测试时运行时，它可以进行Node 'Test ; 套房， Node 'Suite ; 在任何一个上，一个多态Node a 。 当Node a上的模式匹配时，每个case分支都可以访问等式约束：

useNode :: Node a -> Foo
useNode node = case node of
  TestNode source ->          {- here it’s known that (a ~ 'Test) -}
  SuiteNode title children -> {- here, (a ~ 'Suite) -}

事实上，如果你把一个具体的Node 'Test中， SuiteNode分支会被编译器被禁止，因为它永远不能比拟的。

SomeNode是一个包含未知类型Node的存在主义者; 如果需要，可以为此添加额外的类约束。

您可以使用Result执行类似的操作：

data ResultType = Success | Omitted | Failure | Skipped

data Result (t :: ResultType) where
  SuccessResult
    :: [Either (Result 'Success) (Result 'Skipped)]
    -> Result 'Success
  FailureResult
    :: [SomeResult]
    -> Result 'Failure
  OmittedResult
    :: [Result 'Omitted]
    -> Result 'Omitted
  SkippedResult
    :: [Result 'Skipped]
    -> Result 'Skipped

data SomeResult where
  SomeResult :: Result t -> SomeResult

当然，我假设你的实际代码中有更多关于这些类型的信息; 事实上，它们并不代表太多。 当您进行动态计算（例如运行可能产生不同类型结果的测试）时，可以将其包装在SomeResult 。

为了处理动态结果，您可能需要向编译器证明两种类型是相等的; 为此，我将你引导到Data.Type.Equality ，它提供了一个类型a :~: b ，当两个类型a和b相等时，它由一个构造函数Refl居住; 您可以对此进行模式匹配，以告知类型检查器类型等式，或使用各种组合器执行更复杂的证明。

与GADTs （以及ExistentialTypes ，较不普遍）一起使用的GADTs RankNTypes ，它基本上允许您将多态函数作为参数传递给其他函数; 如果你想要一般地消费一个存在主义，这是必要的：

consumeResult :: SomeResult -> (forall t. Result t -> r) -> r
consumeResult (SomeResult res) k = k res

这是继续传递样式 （CPS）的示例，其中k是延续。

最后要注意的是，这些扩展被广泛使用并且在很大程度上没有争议; 当你让它们更直接地表达你的意思时，你不必担心选择（大多数）类型系统扩展。