多态性类型：使用相同类型的同义词表示多种类型

Question

我的目标是给出两种数据类型相同的同义词。 我将我的问题最小化了以下问题：

{-# LANGUAGE KindSignatures, Rank2Types #-}

class Things (h :: * -> *) where

newtype Thing1 a = Thing1 a
newtype Thing2 a = Thing2 a

instance Things Thing1 where
instance Things Thing2 where

type OneOfTwo a = forall h. Things h => h a

foo :: OneOfTwo String -> String
foo (Thing1 name) = name
foo (Thing2 name) = name

我的目标是能够制作类型的同义词OneOftwo代表Thing> Thing> Thing> Thing> Thing> Thing> thite> thits> thite2 thing2 （如果我愿意的话，甚至更多）。但是，当我这样做时，除了foo中的第一个模式外，任何匹配的模式都将被视为多余的：

    Pattern match is redundant
   |
15 | foo (Thing2 name) = name
   |

我知道我可以将其重新编写为以下内容：

newtype Thing1 a = Thing1 a
newtype Thing2 a = Thing2 a

data OneOfTwo a = One (Thing1 a)
                | Two (Thing2 a)

foo :: OneOfTwo String -> String
foo (One (Thing1 name)) = name
foo (Two (Thing2 name)) = name

但是我想避免创建创建新的数据类型OneOftwo。

是否有解决方法可以实现这一目标而不创建新的拳击数据类型？

Answer 1

您已经尝试构建存在类型

type OneOfTwoE a = ∃ h. Things h => h a

的意思是“使用Value V的人Oneoftwo a可以确保有一些具体类型构造函数h，它是things的实例，因此v具有类型h a”。但这不是 您写的类型是什么意思；那是通用类型，

type OneOfTwoA a = ∀ h. Things h => h a

这意味着对于 act 类型构造函数h v的用户可能会想到，<代码> v 具有类型h a。即单个值v一般具有多种不同类型！

这意味着，尽管在不同的构造函数上匹配，但您实际上可以编写

fooA :: OneOfTwoA String -> String
fooA v = (case v of {Thing1 name -> name})
       ++ (case v of {Thing2 name -> name})

案例匹配的两个将成功！之所以起作用，是因为在每个案例表达式中，v专门针对不同的h实例化，这是可以的，因为类型是通用的。

Haskell实际上没有存在类型。正如您所指出的那样，它确实具有歧视总量类型。它还可以模拟具有普遍量化的数据构造函数的存在类型，可优先用GADT语法表达：

data OneOfTwoG a where
  OneOfTwo :: ∀ h a . Things h => h a -> OneOfTwoG a

这使得在概念上可以将类似于（ 此代码不起作用）的东西成为

fooG :: OneOfTwoG String -> String
fooG (OneOfTwo (Thing1 name)) = name
fooG (OneOfTwo (Thing2 name)) = name

可能实际上获得该功能，您需要将案例区别放在课堂实例中，就像

class Things (h :: * -> *) where
  gname :: h a -> a

newtype Thing1 a = Thing1 a
newtype Thing2 a = Thing2 a

instance Things Thing1 where gname (Thing1 n) = n
instance Things Thing2 where gname (Thing2 n) = n
fooG :: OneOfTwoG String -> String
fooG (OneOfTwo ϑ) = gname ϑ

Answer 2

出于明显指出的风险，类型类的全部目的是允许您定义可以应用于多种类型的多态性功能，因此在这种情况下您假定要做的是写：

class Things h where
  foo :: h String -> String

newtype Thing1 a = Thing1 a
newtype Thing2 a = Thing2 a

instance Things Thing1 where
  foo (Thing1 name) = name
instance Things Thing2 where
  foo (Thing2 name) = name

也就是说，当您要用单个名称表示多种类型时，要使用的工具是类型类，而不是类型的同义词。