Haskell中的评估、let和位置

我目前正在学习Haskell，并试图了解TypeClass是如何计算的，以及

let

和

在哪里工作。此代码运行良好：

{-# 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，但遇到了相同的问题。
问题是
literal 200
在第一个示例的两个不同上下文中的解释不同。把它想象成

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

仅根据类型，编译器确定第一个
literal 100
必须具有类型
Integer
，因为它将被传递到
强制Integer
，因为它必须采用类型
Integer
的值。这还将
（：）
的类型设置为现在的
整数->[Integer]->[Integer]
，这意味着最后一个
文本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

没有任何问题，这将打印出
[100100100100100100100]
。不过，需要初始的
强制Integer
，因为否则编译器将不知道将其实例化为什么，因此不会有
打印的
显示
实例