类型类和重载，有什么联系？

Question

我目前正试图围绕类型类和实例展开思考，但我还不太了解它们的意义。到目前为止，我对此事有两个问题：

1) 当函数使用某个类型类中的某个函数时，为什么必须在函数签名中包含类型类。示例：

f :: (Eq a) => a -> a -> Bool
f a b = a == b

为什么要在签名中输入(Eq a)。如果== 没有为a 定义，那么为什么不直接在遇到a == b 时抛出错误呢？必须提前声明类型类有什么意义？

2) 类型类和函数重载有什么关系？

这是不可能的：

data A = A
data B = B

f :: A -> A
f a = a

f :: B -> B
f b = b

但可以这样做：

data A = A
data B = B

class F a where
  f :: a -> a

instance F A where
  f a = a

instance F B where
  f b = b

这是怎么回事？为什么我不能有两个具有相同名称但在不同类型上运行的函数...来自 C++ 我觉得这很奇怪。但我可能对这些东西到底是什么有错误的概念。但是一旦我将它们包装在这些类型类实例中，我就可以了。

也可以随意向我投掷类别或输入理论词，因为我在学习这些主题的同时学习 Haskell，我怀疑这些主题中有 Haskell 如何在这里做事的理论基础。

Answer 1

我同意Willem Van Onsem’s answer 的大部分观点，但我认为它忽略了类型类相对于真正的临时重载的主要优势之一：抽象。想象一下，我们使用临时重载而不是类型类来定义 Monad 操作：

-- Maybe
pure :: a -> Maybe a
pure = Just

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b
Just x >>= f = f x
Nothing >>= _ = Nothing

-- Either
pure :: a -> Either e a
pure = Right

(>>=) :: Either e a -> (a -> Either e b) -> Either e b
Right x >>= f = f x
Left err >>= _ = Left err

现在，我们知道每个 monad 都可以用 pure 和 >>= 表示，如上所述，但是我们也知道它们可以用 fmap 等价表示，@ 987654327@ 和 join。因此，我们应该能够实现一个适用于 any monad 的join 函数：

join x = x >>= id

但是，现在我们遇到了一个问题。 join的类型是什么？

很明显，join 必须是多态的，因为它在设计上适用于任何 monad。但是给它类型签名forall m a. m (m a) -> m a 显然是错误的，因为它并不适用于所有类型，只适用于一元类型。因此，我们需要在我们的类型中表达需要存在一些操作(>>=) :: m a -> (a -> m b) -> m b，这正是类型类约束提供的。

鉴于此，很明显，即席重载可以重载名称，但不可能对这些重载名称进行抽象，因为不能保证不同的实现以任何方式相关。你可以定义没有类型类的 monad，但是你不能定义 join、when、unless、mapM、sequence，以及你得到的所有其他好东西只需定义两个操作即可免费使用。

因此，Haskell 中需要类型类来实现代码重用并避免大量重复。但是你能both 类型类风格的重载和类型导向的临时名称重载吗？ 是的，事实上，Idris 确实如此。但是 Idris 的类型推断与 Haskell 的非常不同，因此由于 Willem 的回答中的许多原因，支持它比在 Haskell 中更可行。

Answer 2

简而言之：因为 Haskell 就是这样设计的。

为什么要在签名中输入(Eq a)。如果 == 没有定义为 a 那么为什么不在遇到 a == b 时抛出错误呢？

为什么我们将类型放在 C++ 程序的签名中（而不仅仅是作为主体中的断言）？因为这就是 C++ 的设计方式。通常，关于构建什么编程语言的概念是“明确需要明确的内容”。

并不是说 Haskell 模块是开源的。这意味着我们只有可用的签名。因此，这意味着当我们例如写：

Prelude> foo A A

<interactive>:4:1: error:
    • No instance for (Eq A) arising from a use of ‘foo’
    • In the expression: foo A A
      In an equation for ‘it’: it = foo A A

我们经常会在这里用没有Eq 类型类的类型写foo。结果，我们会得到很多只在编译时发现的错误（或者如果 Haskell 是一种动态语言，在运行时）。将Eq a放入类型签名的想法是，我们可以提前查找foo的签名，从而确保类型是typeclass的实例。

请注意，您不必自己编写类型签名：Haskell 通常可以派生函数的签名，但签名应包含有效调用和使用函数所需的所有信息。通过添加类型约束，我们加快了开发速度。

这是怎么回事？为什么我不能有两个同名但在不同类型上运行的函数。

再说一遍：这就是 Haskell 的设计方式。函数式编程语言中的函数是“一等公民”。这意味着这些通常有一个名称，我们希望尽可能避免名称冲突。就像 C++ 中的类通常具有唯一的名称（命名空间除外）。

假设您将定义两个不同的函数：

incr :: Int -> Int
incr = (+1)

incr :: Bool -> Bool
incr _ = True

bar = incr

那么incr 必须选择哪个bar？当然我们可以明确类型（即incr :: Bool -> Bool），但通常我们希望避免这种工作，因为它会引入很多噪音。

我们不这样做的另一个很好的原因是，通常类型类不仅仅是函数的集合：它向这些函数添加契约。例如Monad 类型类必须满足函数之间的某些关系。例如(>>= return) 应该与id 等价。换句话说，类型类：

class Monad m where
    (>>=) :: m a -> (a -> m b) -> m b
    return :: a -> m a

没有描述两个独立函数(>>=)和return：这是一组函数。您同时拥有它们（通常在特定的 >>= 和 return 之间有一些合同），或者根本没有。

Answer 3

这仅回答问题 1（至少直接回答）。

类型签名f :: a -> a -> Bool 是f :: forall a. a -> a -> Bool 的简写。如果f 仅适用于定义了(==) 的as，则f 不会真正适用于所有 类型a。这种对具有(==) 的类型的限制是使用f :: forall a. (Eq a) => a -> a -> Bool 中的约束(Eq a) 来表达的。

“For all”/通用量化是 Haskell（参数）多态性的核心，除其他外，还提供了 parametricity 的强大而重要的属性。

Answer 4

Haskell 坚持两个公理（除其他外）：

1. 每个变量都可以单独用作表达式；
2. 每个表达式都有一个类型，精确地指定你可以用它做什么。

如果你有

f :: A -> A

和

f :: B -> B

那么，根据 Haskell 中采用的原则，f 仍然是一个有效的表达式，它本身仍然必须有一个 single 类型。虽然可以使用子类型来做到这一点，但它被认为比类型类解决方案复杂得多。

同样需要Eq a in

(==) :: Eq a => a -> a -> Bool

来自== 的类型必须完整描述您可以用它做什么的事实。如果您只能在某些类型上调用它，则类型签名必须反映这一点。