2

假设我有一个像这样的语言的 GADT（我的实际语言要复杂得多，大约有 50 个构造函数，但这是一个简化的示例）：

data Expr t where
  Add :: Expr t -> Expr t -> Expr t
  Sub :: Expr t -> Expr t -> Expr t
  Mult :: Expr t -> Expr t -> Expr t
  Negate :: Expr t -> Expr t
  Abs :: Expr t -> Expr t
  Scalar :: t -> Expr t

现在让我们定义另一个数据类型，如下所示：

data BinOpT = AddOp | SubOp | MultOp

另外，假设我有以下功能：

stringBinOp :: BinOpT -> String
stringBinOp AddOp = "+"
stringBinOp SubOp = "-"
stringBinOp MultOp = "*"

另外，让我们定义以下类型：

data BinOp t = BinOp BinOpT (Expr t) (Expr t)

现在我想定义一个漂亮的打印功能，如下所示：

prettyPrint :: Show t => Expr t -> String
prettyPrint (BinOp op x y) = prettyPrint x ++ showOp op ++ prettyPrint y
prettyPrint (Negate x) = "-" ++ prettyPrint x
prettyPrint (Abs x) = "abs(" ++ prettyPrint x ++ ")"
prettyPrint (Scalar x) = show x

请注意，这是无效的，因为BinOp它不是Expr t.

当然我可以Expr t像这样重新定义：

data Expr t where
  BinOp :: BinOp -> Expr t -> Expr t -> Expr t
  Negate :: Expr t -> Expr t
  Abs :: Expr t -> Expr t
  Scalar :: t -> Expr t

这会很好，但我宁愿不这样做。它使使用它的其他代码更难看，而且我认为它在空间和时间方面效率会稍微低一些，而且你必须匹配两个构造函数而不是一个，这意味着两个 case 语句（因此跳转表）而不是一个。

我怀疑我可以使用以下两个 GHC 扩展的组合来实现我想要干净地做的事情，即：

{-# LANGUAGE ViewPatterns #-}
{-# LANGUAGE PatternSynonyms #-}

但我不太确定如何最好地做到这一点。此代码的一个简单示例会很有帮助（然后我可以将其应用于我正在处理的更复杂的语言）。

如果解决方案在编译时不会因缺少模式匹配而发出警告，则会获得许多假想的奖励积分。我知道 GHC 8.2 在这方面可能会有所帮助，因此具有详尽性检查扩展的 GHC 8.2 示例会很好，尽管通过详尽性检查器的预 GHC 8.2 解决方案会更好。

澄清：

我实际上要问的是我怎么能做这样的事情：

prettyPrint :: Show t => Expr t -> String
prettyPrint (BinOp op x y) = prettyPrint x ++ showOp op ++ prettyPrint y
prettyPrint (Negate x) = "-" ++ prettyPrint x
prettyPrint (Abs x) = "abs(" ++ prettyPrint x ++ ")"
prettyPrint (Scalar x) = show x

在保持这样的定义的同时Expr t：

data Expr t where
  Add :: Expr t -> Expr t -> Expr t
  Sub :: Expr t -> Expr t -> Expr t
  Mult :: Expr t -> Expr t -> Expr t
  Negate :: Expr t -> Expr t
  Abs :: Expr t -> Expr t
  Scalar :: t -> Expr t

重要的一行是：

prettyPrint (BinOp op x y) = prettyPrint x ++ showOp op ++ prettyPrint y

不会编译，因为BinOp它不是Expr t. 我想要这样可以编译的行，因为我不想到处这样做：

prettyPrint (Add x y) = ...
prettyPrint (Sub x y) = ...
prettyPrint (Mult x y) = ...

因为这意味着很多代码重复，因为很多函数都会使用Expr t.

4

1 回答 1

9

查看模式

asBinOp (Add a b) = Just (AddOp, a, b)
asBinOp (Sub a b) = Just (SubOp, a, b)
asBinOp (Mul a b) = Just (MulOp, a, b)
asBinOp _ = Nothing

prettyPrint (asBinOp -> Just (op, x, y)) = prettyPrint x ++ showOp op ++ prettyPrint y

... + 模式同义词

pattern BinOp :: BinOpT -> Expr t -> Expr t -> Expr t
pattern BinOp op a b <- (asBinOp -> Just (op, a, b)) where
  BinOp AddOp a b = Add a b
  BinOp SubOp a b = Sub a b
  BinOp MulOp a b = Mul a b

prettyPrint (BinOp op x y) = prettyPrint x ++ showOp op ++ prettyPrint y

In GHC 8.2, you can satisfy the exhaustiveness checker with this pragma:

{-# COMPLETE BinOp, Negate, Abs, Scalar #-}
于 2017-05-08T03:00:29.387 回答