懒惰是否也意味着函数的值取决于调用它的上下文？

Question

我正在尝试学习 Haskell，在使用应用函子时，我发现一件事让我很困惑。

让我们定义以下函数g，它返回一些函子：

*Main> let g = pure (2*)
*Main> :t g
g :: (Num a, Applicative f) => f (a -> a)

由于返回类型是 some 函子，我可以在这两个函数中使用 g 作为参数：

f1 :: (Num a) => [a -> a] -> a
f1 (g:[]) = g 3

f2 :: (Num a) => Maybe (a -> a) -> a
f2 (Just g) = g 4

但这意味着函数 g 返回的值也取决于将被评估的上下文！ （可能是 List 和 Maybe。）这也是懒惰的属性吗？因为到目前为止，我一直在以一种在需要时计算值的方式来考虑惰性，但它在定义时已经确定（对于 g in let 表达式）。

Answer 1

正如@augustss 所说，这与懒惰无关，而是您正在使用类型类这一事实。为了使这一点更清楚，您可以通过显式传递包含类定义的所有函数的记录来对类型类进行建模。如果您想查找有关它的更多信息，这种技术称为字典传递。

我们从一些扩展开始。

{-# LANGUAGE RankNTypes      #-}
{-# LANGUAGE RecordWildCards #-}

然后给记录类型打包Applicative 应该具有的功能（实际上，您还会有一个字段说f 是Functor，但为简洁起见，我在此省略）。

data Applicative f =
  Applicative { pure :: forall a. a -> f a
              , app  :: forall a b. f (a -> b) -> f a -> f b
              }

我们可以将您的函数 g 定义为记录说 f 是 Applicative 并提供您所描述的行为（我将 Num 保留为类约束，但类似地，它可能是翻译为记录传递）。

g :: Num a => Applicative f -> f (a -> a)
g Applicative{..} = pure (2*)

您的两个函数 f1 和 f2 仍然是有效定义：

f1 :: Num a => [a -> a] -> a
f1 (g:[]) = g 3

f2 :: Num a => Maybe (a -> a) -> a
f2 (Just g) = g 4

现在，我们想将它们应用到 g，但有一个问题：g 的函数类型期望传递 Applicative f 记录。好吧，我们可以定义Applicative 的[] 和Maybe 实例：

applicativeList :: Applicative []
applicativeList =
  Applicative { pure = (:[])
              , app  = \ fs as -> fs >>= \ f -> fmap f as
              }

applicativeMaybe :: Applicative Maybe
applicativeMaybe =
  Applicative { pure = Just
              , app  = \ fs as -> fs >>= \ f -> fmap f as
              }

然后我们必须为应用程序选择正确的类型进行类型检查（[] 用于f1 和Maybe 用于f2）：

f1g = f1 (g applicativeList)
f2g = f2 (g applicativeMaybe)