函数 g = (.).(.) 的类型是什么？

Question

答案是：(a -> b) -> (c -> d -> a) -> c -> d -> b

但我不知道怎么去那里。

Answer 1

(.) 的类型为 (b -> c) -> ((a -> b) -> (a -> c))。为了清楚起见，我故意添加了一些括号。在表达式 (.) . (.) 中有三个 (.) 实例，因此在三个版本中使用不同字母的类型会很方便。

• (.) :: (b -> c) -> ((a -> b) -> (a -> c)) – (.) 的第一个实例：(.).(.)

• (.) :: (e -> f) -> ((d -> e) -> (d -> f)) – (.) 的第二个实例：(.). (.)

• (.) :: (h -> i) -> ((g -> h) -> (g -> i)) – (.) 的第三个实例：(.) .(.)

(.) . (.) 等效于((.) (.)) (.)，它将(.) 应用于(.)，然后将第一个应用程序的结果应用于(.)。

第一个实例应用于第二个实例

将参数的类型（(e -> f) -> ((d -> e) -> (d -> f))）匹配到(.)的输入类型（b -> c）：

b = (e -> f)
c = ((d -> e) -> (d -> f))

然后将(.) ((a -> b) -> (a -> c)) 结果类型中的类型变量替换为参数中的匹配项：

(.) (.) :: (a -> (e -> f)) -> (a -> ((d -> e) -> (d -> f)))

将第一个应用的结果应用到第三个实例

将参数的类型（(h -> i) -> ((g -> h) -> (g -> i))）匹配到(.) (.)的输入类型（a -> (e -> f)）：

a = (h -> i)
e = (g -> h)
f = (g -> i)

然后将(.) (.) (a -> ((d -> e) -> (d -> f))) 结果类型中的类型变量替换为参数中的匹配项：

(.) (.) (.) :: (h -> i) -> ((d -> (g -> h)) -> (d -> (g -> i)))

这与您在问题中的类型相同，只是括号和字母不同。如果我删除不必要的括号，结果如下：

(.) (.) (.) :: (h -> i) -> (d -> g -> h) -> d -> g -> i

它有什么作用？它接受d 和g 类型的两个参数，将d -> g -> h 类型的函数应用于它们，然后将h -> i 类型的函数应用于结果。

Answer 2

类型(.) :: (b->c) -> (a->b) -> (a->c) 表示

    g :: a -> b
f     ::      d -> c
--------------------    d ~ b
f . g :: a ->      c

因此

      (.) :: (b->c) -> ((a->b) -> (a->c))
(.)       ::           (   s   ->    r  ) -> (t->s) -> (t->r)
-------------------------------------------------------------
(.) . (.) :: (b->c) ->                       (t->s) -> (t->r)
          ~  (b->c) ->                    (t->a->b) ->  t->a->c 

这是有道理的，因为

  ((.) . (.))   f                            g          x  y =
 = (.) ((.) f) g x y
 =    ((f .) . g) x y = (f .) (g x) y 
                      = (f . g x) y    = f ( g          x  y )

因为(.) f g x = (f .) g x = (f . g) x = f (g x)（还有= (. g) f x）。

(f .) 被称为运算符部分（带有(.) 运算符）。这是写(.) f的便捷快捷方式。