评估，让我们在Haskell中

Question

目前，我正在学习Haskell，并试图了解的类型类是如何评估，以及如何let并where工作。 这段代码运行正常：

{-# LANGUAGE FlexibleInstances #-}
class Expr a where
    literal :: Integer -> a

instance Expr Integer where
    literal = id

instance Expr [Integer] where
    literal i = [i]

coerceInteger :: Integer -> Integer
coerceInteger = id

main = print $ coerceInteger (literal 100) : literal 100 -- Prints [100,100]

但改变主要功能

main = print $ coerceInteger expr : expr
    where expr = literal 200

导致编译器错误：

Couldn't match expected type `[Integer]' with actual type `Integer'
In the second argument of `(:)', namely `expr'
In the second argument of `($)', namely `coerceInteger expr : expr'
In the expression: print $ coerceInteger expr : expr

我猜这是因为在第一个main方法中， literal 100被评估两次，而在第二个示例中， literal 200仅被评估一次，因此编译器被迫选择一个类型。

如何分解代码以避免重复自己，而不会导致此错误？ 我尝试let expr = literal 300 in ...使用let expr = literal 300 in ...但遇到了同样的问题。

Answer 1

问题是在第一个例子的两个不同的上下文中对literal 200的解释是不同的。 把它想象成

((:) :: a -> [a] -> [a])
    ((coerceInteger :: Integer -> Integer) (literal 100 :: Expr a => a))
    (literal 100 :: Expr a => a)

基于类型，编译器确定第一个literal 100必须具有Integer类型，因为它被传递给coerceInteger ，因为它必须采用Integer类型的值。 这也将(:)的类型设置为现在为Integer -> [Integer] -> [Integer] ，暗示最后一个literal 100必须具有[Integer]类型。

在第二个例子中，你说它们都具有相同的值，因此是相同的类型，这是不可能的，因为第二个必须是(:)键入check的列表。

这实际上是因为可怕的单态限制。 您可以通过两种方式解决此问题：一，使用{-# LANGUAGE NoMonomorphismRestriction #-}关闭单态限制，或者您可以为expr提供一个显式类型，使其保持一般化：

main :: IO ()
main = print $ coerceInteger expr : expr
    where
        expr :: Expr a => a
        expr = literal 100

这些方法中的任何一种都可以工作，无论您决定做什么，我都建议始终提供类型签名以帮助避免这些问题。

---

事实上，一旦你添加了类型签名，你甚至可以做类似的事情

main :: IO ()
main = print $ coerceInteger expr : expr : expr : expr : expr : expr
    where
        expr :: Expr a => a
        expr = literal 100

没有任何问题，这将打印出[100, 100, 100, 100, 100, 100] 。 但是需要初始的coerceInteger ，因为否则编译器将不知道将其实例化为什么，因此不会有用于print的Show实例。