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 ...，但遇到了同样的问题。

Answer 1

问题在于literal 200在第一个示例的两个不同上下文中的解释方式不同。把它想象成

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

根据类型，编译器确定第一个literal 100必须具有类型Integer，因为它必须传递给coerceInteger，因为它必须采用类型{{ 1}}。这也将Integer的类型设置为(:)，这意味着最后Integer -> [Integer] -> [Integer]必须包含literal 100类型。

在第二个例子中，你说它们都具有相同的值，因此是相同的类型，这是不可能的，因为第二个必须是[Integer]列表进行类型检查。

这实际上是因为可怕的单态限制而发生的。您可以通过两种方式解决此问题：一，使用(:)关闭单态限制，或者您可以为{-# 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没有Show实例。

评估，让我们在Haskell中

1 个答案: