属于两种不同类型的一个值构造函数

Question

假设我有三个值构造函数：

A { a :: Int }
B { b :: Char }
C { c :: Bool }

我想创建X 和Y 两种类型，这样X 类型的值可以是A、B 或C，如下所示：

data X = A {...} | B {...} | C {...}

而Y 类型的值只能是A 或B，如下所示：

data Y = A {...} | B {...}

这样我就可以编写如下代码：

foo :: X -> Int -- can pattern match
foo (A _) = 1
foo (B _) = 2
foo (C _) = 3
bar :: Y -> Bool -- also can pattern match with the same constructors
bar (A _) = true
bar (B _) = false
baz = A 1 -- baz is inferred to be a type that can fit in both X and Y

我知道我可以将构造函数包装在 X 和 Y 的定义中，如下所示：

data X = XA A | XB B | XC C
data Y = YA A | YB B

但这似乎不整洁（必须一直输入XA A 等）。我可以将A、B和C的内容扩展为X和Y的定义，但是A等非常复杂，我不想重复定义。

这对 Haskell 是否可行，包括任何 GHC 扩展？

编辑

GADT 似乎可以按要求回答我的问题（因此我将散热器的回答标记为正确），但仍然不够灵活，无法满足我的需要。例如，据我所知，您不能执行以下操作：

func1 :: [XY Y_] -- returns a list of items that can only be A or B
func1 = ...
func2 = func1 ++ [C True] -- adding a C item to the list

func2 应该输入为[XY X_]，但这在 Haskell 中是不可能的（除非我的实验是错误的）。

经过更多的网络搜索，我真正想要的是 OCaml 的多态变体（据我所知）仅存在于 OCaml 中（着眼于更“实用”而不是“学术”语言）。

编辑 2

查看comonad的回答。看来真的可以，不过我觉得这个问题最好不要重写太多次。 :-)

Answer 1

如jetxee 所述，类型类可能是合适的方法。

如果您还想要模式匹配和使用构造函数的能力，那么您可以使用 GADT 和空数据声明在一种数据类型中定义所有构造函数。如果采用这种方法，所有构造函数都将是相同数据类型的成员，同时允许您将域限制为仅构造函数的子集。

data X_
data Y_
data XY a where
  A :: Int -> XY a
  B :: Char -> XY a
  C :: Bool -> XY X_
type X = XY X_ -- Contains values built with constructors A, B, and C 
type Y = XY Y_ -- Contains only values built with constructors A and B

现在只使用A 和B 的函数适用于X 和Y 这两种类型。使用 C 的函数仅适用于类型 X。

Answer 2

baz = A 1 -- baz is inferred to be a type that can fit in both X and Y

这需要 Haskell 支持某种形式的子类型，但它不支持。也没有支持此功能的 ghc 扩展。

你能做的最好的事情可能是这样的：

data Y = A ... | B ...
data X = XY Y | C ...

这样您就不必重复构造函数A 和B，也不必编写Y (A foo) - 您只需编写A foo 即可获得Y 类型的值.

但是，您必须编写 X (A foo) 才能获得包含 A 的 X 类型的值。这不是您想要的，但恐怕是您最接近的。

Answer 3

您对foo 和bar 的定义不会进行类型检查，因为根据定义A _ 是A 类型的值，而不是X 或Y。您不能拥有具有相同构造函数的其他类型 (X)。所以，正确的是你写的：

data X = XA A | XB B | XC C
data Y = YA A | YB B

但是让我们从另一个角度来处理它。 为什么你需要那个？你想表达的是，X 可以是A、B 或C，而Y 可以是A 或B。您不关心 A、B 和 C 的值。所以成为A和成为B是X和Y共同的特征。

当您在两种类型（本例中为X 和Y）之间具有共同特征时，您通常可以使用类型类来表达它。请注意，类型类是开放的，因此可以根据需要实现任意数量的类型。

例如，我们可以定义三个类型类来检查类型是否有A、B或C：

class HasA t where hasA :: t -> Bool
class HasB t where hasB :: t -> Bool
class HasC t where hasC :: t -> Bool

现在对于我们的类型，我们仍然必须使用不同的数据构造函数：

data A = A Int
data B = B Char
data C = C Bool
data X = XA A | XB B | XC C
data Y = YA A | YB B

但我们可以为X 和Y 定义类实例：

instance HasA X where
  hasA (XA _) = True
  hasA _ = False
instance HasB X where 
  hasB (XB _) = True
  hasB _ = False
instance HasC X where
  hasC (XC _) = True
  hasC _ = False

instance HasA Y where 
  hasA (YA _) = True
  hasA _ = False
instance HasB Y where 
  hasB (YB _) = True
  hasB _ = False
instance HasC Y where 
  hasC = const False

使用这些类型类，您可以编写foo 和bar，它们同时接受Xs 和Ys。

foo :: (HasA t, HasB t, HasC t) => t -> Int
foo v | hasA v = 1
      | hasB v = 2
      | hasC v = 3
      | otherwise = undefined
bar :: (HasA t, HasB t) => t -> Bool
bar v | hasA v = True
      | hasB v = False
      | otherwise = undefined

xs = [ XA (A 1), XB (B '1'), XC (C True) ]
ys = [ YA (A 1), YB (B '1') ]

更准确地说，foo 接受实现HasA、HasB 和HasC 的anything，而bar 接受实现HasA 的anything和HasB（在bar的上下文中是否实现HasC是无关紧要的）。如果实现碰巧在每种情况下都返回False，那么foo 和bar 是未定义的。

例如：

ghci> map foo xs
[1,2,3]
ghci> map foo ys
[1,2]
ghci> map bar xs
[True,False,*** Exception: Prelude.undefined
ghci> map bar ys
[True,False]

请注意bar 也接受Xs，但如果它碰巧是除A 或B 之外的其他东西，则它是未定义的。在这种情况下，作为程序员，而不是编译器，您有责任考虑警卫的详尽性。

如果您还需要A、B 和C 的值，则必须以不同的方式设计类型类，例如喜欢

class HasA t where getA :: t -> Maybe A

但想法是一样的。

Answer 4

使用散热器的答案，我想出了这个：

{-# LANGUAGE GADTs,EmptyDataDecls #-}
module Test where


data NotThatY
data XY a where
  A :: Int -> XY a
  B :: Char -> XY a
  C :: Bool -> XY NotThatY

type Y a = XY a
type X a = XY NotThatY -- or type X =..., but (X a) looks better alongside (Y a).

func1 :: [Y a]
func1 = [A 5, B 'ö']
func2 :: [X a]
func2 = func1 ++ [C True]

对是的限制被删除。现在它可以工作了，但是类型中的 a 看起来有点奇怪。

type Y = forall a. XY a -- 不起作用。