派生 Haskell 类型和 (<*>)(<*>) 的实现

Question

我是新手，刚开始学习 Haskell，所以如果我提出愚蠢的问题，请多多包涵。

最近我在 SO 中遇到了一些问题，演示了如何推导函数和表达式的类型和实现（例如

How can I understand "(.) . (.)"?

&

Haskell function composition, type of (.)(.) and how it's presented )

我觉得答案很鼓舞人心

然后，我尝试为自己设计一些练习，以确保我知道如何应用这些技巧。

然后我自己想出了这个表达式：(<*>)(<*>)，我不知道如何解决。

在 GHCi 中，它给出的类型签名为：

(<*>)(<*>) :: Applicative f => (f (a -> b) -> f a) -> f (a -> b) -> f b

但我的问题是如何从

开始

(<*>) :: Applicative f => f (a -> b) -> f a -> f b

并导出 GHCi 给出的类型签名？

另外，基于类型签名，(<*>)(<*>) = ??的实现会是怎样的？

我被卡住了，无法通过重新排列术语等技术解决这个问题。我什至不知道从哪里开始。

有人可以帮我吗？

非常感谢

注意**：(<*>)(<*>)这个表达式确实没有什么特殊含义，只是我自己随机想出来的一个练习

Answer 1

首先，我们用两组不相交的类型变量写出(<*>)的类型：

(<*>) :: (Applicative f) => f (a -> b) -> f a -> f b
(<*>) :: (Applicative g) => g (c -> d) -> g c -> g d

如果我们想用第二个和第一个作为参数，我们需要

g (c -> d) ~ f (a -> b) -> f a -> f b

屈服

g ~ (f (a -> b) ->)    or,   ((->) (f (a -> b)) )
c ~ f a
d ~ f b

并注意g 的选择确实是一个应用函子：它是非新类型的Reader (f (a -> b)) 应用程序。

所以应用程序有类型

g c -> g d

我们现在知道的

(f (a -> b) -> f a) -> (f (a -> b) -> f b)

q.e.d.

Answer 2

作为一个练习，将其缩小到函数，其中<*> 只是一个S-组合子，

Prelude> let s f g x = f x (g x)

Prelude> :t s s
s s :: ((t -> t1 -> t2) -> t -> t1) -> (t -> t1 -> t2) -> t -> t2
--               g2          g4                 g2          g1
--         g3                             g3
--                      g5
--                                  g6

重要的是要知道类型中的箭头关联到右侧，所以((t -> t1 -> t2) -> t -> t1) 实际上是((t -> t1 -> t2) -> (t -> t1))，而(t -> t1 -> t2) 是(t -> (t1 -> t2))。

实现：

g6 g5 g3 t :: t2 
  g3 t t1 :: t2          -- need t1
  g5 g3 t :: t1
  g3 t (g5 g3 t) :: t2   -- so, 

h f g x = g x (f g x)    

所以，当我们有类型时，可以说是连接电线，或者将乐高积木拼在一起。我们尝试查看给定实体（参数）的哪些组合具有什么类型，如果它们对获得所需的输出类型有用（t2，上文），则在进一步的组合中使用它们。

同样，

Prelude Control.Applicative> :t (<*>) (<*>)
(<*>) (<*>) :: (Applicative f) =>
               (f (a -> b) -> f a) -> f (a -> b) -> f b
--                         f          fg
Prelude Control.Applicative> :t let axa f fg = fg <*> f fg in axa
let axa f fg = fg <*> (f fg) in axa :: (Applicative f) =>
                                       (f (a -> b) -> f a) -> f (a -> b) -> f b

Answer 3

此外，基于类型签名，如何实现 (<*>)(<*>) = ?? 会是？

颠倒顺序更容易（先找到实现，然后派生出它的类型）。

函数的应用实例是

instance Applicative ((->) a) where
    pure = const
    (<*>) f g x = f x (g x)

因此，只需将上述定义中的<*> 替换为f，(<*>) (<*>) 就是\g x -> x <*> g x。或者经过 alpha 转换后 \g h -> h <*> g h.

由于(<*>) 的第一个参数是h，对于某些a 和b 必须是h :: f (a -> b) 类型，其中f 在Applicative 中。

由于g 接收h 作为参数，它必须是g :: f (a -> b) -> c 类型，对于某些c。

由于(<*>)的第一个参数h的类型是f (a -> b)，而(<*>)的第二个参数是g h，所以它的类型一定是g h :: f a，因为这样

(<*>) :: f (a -> b) -> f a -> f b

由于g :: f (a -> b) -> c和g h :: f a，

h :: f (a -> b)
g :: f (a -> b) -> c
g h :: f a               ,  c ~ f a   (!)

由于h 的类型为f (a -> b)，h <*> (whatever :: f a) 的类型为f b。

总的来说：

h         :: f (a -> b)
g         :: f (a -> b) -> f a
h <*> g h :: f b

所以我们有

\g h -> h <*> g h :: (f (a -> b) -> f a) -> f (a -> b) -> f b

Answer 4

所以我们有了函数

(<*>) :: Applicative f => f (a -> b) -> f a -> f b

并应用于它<*> :: Applicative g => g (c -> d) -> g c -> g d（我替换了类型变量，因为(<*>)(<*>)的内部和外部<*>具有不同的含义。如果我们将第二个<*>应用于第一个<*>，那么第二个@ 987654327@ 必须是 f (a -> b) 类型。所以我们有以下类型等式：

g (c -> d) -> g c -> g d = f (a -> b)

但是g (c -> d) -> g c -> g d 是(->) (g (c -> d)) (g c -> g d) 的语法糖。所以：

(->) (g (c -> d)) (g c -> g d) = f (a -> b)

双方的类型构造函数和参数类型必须相等，所以：

(->) (g (c -> d)) = f

和

(g c -> g d) = (a -> b)

这意味着a = g c 和b = g d。

现在我们可以看到第一个(<*>)的返回值为

f a -> f b = ((->) (g (c -> d)) (g c)) -> ((->) (g (c -> d)) (g d))
           = (g (c -> d) -> g c) -> (g (c -> d) -> g d)

这与(f (a -> b) -> f a) -> f (a -> b) -> f b 模重命名变量相同。

此示例中的棘手部分是 (->) (g (c -> d)) 是 Applicative（与任何其他 (->) e 相同）。