如何手动推断＆＃39;（。）的类型。 （。）。 ＆＃39（。）;

Question

在Edward Kmett的演讲Lenses, Folds, and Traversals中，在幻灯片上＆＃34; The Power在Dot＆＃34;中，他显示了(.) . (.) . (.)的类型

(a -> b) -> (c -> d -> e -> a) -> c -> d -> e -> b

我可以通过在GHCI中显示它的类型来看到它。但我也想知道原因。我想要理解的另一件事是为什么在(.)到(.) . (.)和(.) . (.) . (.)之间定期更改参数的模式：

(.)             :: (a -> b) -> (c ->           a) -> c ->           b
(.) . (.)       :: (a -> b) -> (c -> d ->      a) -> c -> d ->      b
(.) . (.) . (.) :: (a -> b) -> (c -> d -> e -> a) -> c -> d -> e -> b

P.S。我试图通过扩展(.) . (.)的函数定义来解决(.) . (.)问题。应用(.)的定义后，我得到了：

\x y z t -> x ((y z) t)

所以我推断了类型：

x :: a -> b
y :: c -> d -> a
z :: c
t :: d

但是我在(.) . (.) . (.)迷路了。而且我不知道这是否是进行手动类型推断的正确方法。

Answer 1

有了功能，

instance Functor ((->) r) where
   -- fmap :: (a -> b) ->   f   a  ->   f   b
   --         (a -> b) -> (r -> a) -> (r -> b)
   fmap          p           q         x = p (q x)   -- fmap = (.)

所以你实际拥有的是fmap . fmap . fmap：

fmap               :: (a -> b) -> f       a   -> f       b
fmap . fmap        :: (a -> b) -> f (g    a)  -> f (g    b)
fmap . fmap . fmap :: (a -> b) -> f (g (h a)) -> f (g (h b))

是

 (a -> b) -> (c -> (d -> (e -> a))) -> (c -> (d -> (e -> b)))   ~
 (a -> b) -> (c ->  d ->  e -> a)   -> (c ->  d ->  e -> b)     

为什么fmap . fmap :: (a -> b) -> f (g a) -> f (g b)？因为，

(fmap . fmap) foo = fmap (fmap foo)
{-
fmap            :: (a  ->  b) -> f a     -> f b
foo             ::  a  ->  b
fmap foo        ::               f a     -> f b
fmap foo        :: g a -> g b
fmap (fmap foo) ::               f (g a) -> f (g b)
-}

机械类型派生是关于类型变量的替换和一致重命名。查看更多信息here或here。

Answer 2

(.) . (.) . (.)分两步减少：首先减少没有圆括号的点：

((.) . (.) . (.)) f = (.) ((.) ((.) f))
                    = (.) ((.) (f .))
                    = (.) ((f .) .)
                    = ((f .) .) .)

秒减少剩余的表达

((f .) .) .) g = ((f .) .) . g
               = \x -> ((f .) .) (g x)
               = \x -> (f .) . g x
               = \x y -> (f .) (g x y)
               = \x y -> f . g x y
               = \x y z -> f (g x y z)

首先，您使用n点在括号中组成n - 1个点。然后将此构造应用于函数f :: a -> b和g并获取(...((f .) .) ... .) g，其中每个点对应于g接收的参数 - 这就是为什么存在模式：每个点都在括号处理g的一个参数，你需要另一个点来组成这个点与之前的所有。在所有减少之后，表达式变为

\x1 x2 ... xn -> f (g x1 x2 ... xn)

它的类型很明显。

一件好事是，如果我们有后缀运算符，我们可以编写（代码在Agda中）

open import Function renaming (_∘′_ to _∘_) using ()

_% = _∘_

postulate
  a b c d e : Set
  f : a -> b
  g : c -> d -> e -> a

fg : c -> d -> e -> b
fg = f % % ∘ g

而不是((f .) .) . g。