Haskell：f a的实际含义是什么？

Question

我偶然发现这段代码fold ((,) <$> sum <*> product)类型签名:: (Foldable t, Num a) => ta -> (a, a)我完全迷失了。

我知道它的作用，但我不知道怎么做。 所以我试着把它分成几小块：

λ: :t (<$>)
(<$>) :: Functor f => (a -> b) -> f a -> f b
λ: :t (,)
(,) :: a -> b -> (a, b)
λ: :t sum
sum :: (Foldable t, Num a) => t a -> a

一切都很好，只是基本的东西。

λ: :t (,) <$> sum
(,) <$> sum :: (Foldable t, Num a) => t a -> b -> (a, b)

而我又迷失了......

我看到有一些神奇的事情会变成ta -> a into fa但它是如何完成的对我来说是个谜。 （ sum甚至不是Functor实例！）

我一直认为fa是某种箱f包含a ，但它看起来像含义深刻得多。

Answer 1

您的示例中的仿函数f是所谓的“reader functor”，其定义如下：

newtype Reader r = Reader (r -> a)

当然，在Haskell中，这是为函数本地实现的，因此在运行时没有包装或解包。

相应的Functor和Applicative实例如下所示：

instance Functor f where
  fmap :: (a -> b) -> (r -> a)_-> (r -> b)
  fmap f g = \x -> f (g x) -- or: fmap = (.)

instance Applicative f where
  pure :: a -> (r -> a) -- or: a -> r -> a
  pure x = \y -> x -- or: pure = const
  (<*>) :: (r -> a -> b) -> (r -> a) -> (r -> b)
  frab <*> fra = \r -> frab r (fra r)   

在某种程度上，读者仿函数也是一个“盒子”，就像所有其他仿函数一样，具有产生类型a的上下文r 。

那么让我们看看(,) <$> sum ：

:t (,) :: a -> b -> (a, b)
:t fmap :: (d -> e) -> (c -> d) -> (c -> e)
:t sum :: Foldable t, Num f => t f -> f

我们现在可以将d类型专门化为a ~ f ， e到b -> (a, b)和c到tf 。 现在我们得到：

:t (<$>) -- spcialized for your case
:: Foldable t, Num f => (a -> (b -> (a, b))) -> (t f -> f) -> (t f -> (b -> (a, b)))
:: Foldable t, Num f => (f -> b -> (f, b)) -> (t f -> f) -> (t f -> b -> (f, b))

应用功能：

:t (,) <$> sum
:: Foldable t, Num f => (t f -> b -> (f, b))

这正是ghc所说的。

Answer 2

简短的回答是f ~ (->) (ta) 。 要了解原因，只需稍微重新排列sum的类型签名，使用->作为前缀运算符而不是中缀运算符。

sum :: (Foldable t, Num a) => (->) (t a) a
                              ~~~~~~~~~~
                                  f

---

通常， (->) r是任何参数类型r的仿函数。

instance Functor ((->) r) where
    fmap = (.)

通过将((->) r)插入到f的fmap类型中，很容易证明(.)是fmap唯一可能的实现：

fmap :: (a -> b) -> f a -> f b
     :: (a -> b) -> ((->) r) a -> ((->) r) b
     :: (a -> b) -> (r -> a) -> (r -> b)

这是合成的类型签名，合成是具有此类型签名的唯一函数。

---

由于Data.Functor将<$>定义为fmap的中缀版本，我们有

(,) <$> sum == fmap (,) sum
            == (.) (,) sum

从这里开始，确认结果类型确实是(Foldable t, Num a) => ta -> b -> (a, b) ，这是一个相对简单但又繁琐的工作。 我们有

(b' -> c') -> (a' -> b') -> (a' -> c')  -- composition
b' -> c' ~ a -> b -> (a,b)              -- first argument (,)
a' -> b' ~ t n -> n                     -- second argument sum
----------------------------------------------------------------
a' ~ t n
b' ~ a ~ n
c' ~ a -> b -> (a,b)
----------------------------------------------------------------
a' -> c' ~ t a -> b -> (a,b)