Haskell 此函数是否有任何用例：foo:：（b->；c）>；（a->；b）>；（a->；c）

对于此功能：

foo:：（b->c）->（a->b）->（a->c）

取自

这是一个没有实际用途的函数吗？除非类型c是此函数中的另一个输入参数，否则无法构造As

（b->c）

与

（a->b）->（a->c）

相同：b&c不是这些函数的输入参数

---

该函数有任何用例吗？

可以构造函数

b->c

——因为

b

和

c

可以是任何类型，那么任何函数都与之兼容。但是函数

foo

本身不能（明智地）构造这样一个函数，因为它不知道

b

和

c

。这是一个很大的好处，因为它大大减少了函数

foo

可能实现的数量。这叫做

---

此函数是函数组合运算符的类型

（.）

：

如果问题是关于在实践中使用函数组合，下面是一个小示例。让我们假设我们想要写一个函数，它计算一个数字列表中所有元素的平方和。我们怎么能那样做？我们可以编写这样的代码：

squareSum xs=sum（map（^2））xs

。但我们也可以使用函数组合：

squareSum=sum。map（^2）

（我在这里使用

作为函数组合，而不是

foo

，但这并不重要）。此示例显示了使用函数组合获得的函数（至少在编译和正确工作的意义上是实用的）。当我们需要组合多个函数（可能部分应用）时，函数组合的好处变得更加明显

我只想补充一点，

（）

可能是任何好的Haskell代码库中最常用的三个函数之一。这当然在我的代码中

---

前三名中的另外两个是由于整型文字而由编译器插入的对

fromInteger

的隐式调用，以及从

do

符号对

（>>=）

的隐式调用。后者在深层意义上与

（.）

的操作相同，但在形状稍有不同的值上。

为了补充其他答案，让我尝试证明只有一个（总）函数

或者，换句话说，

foo=（）

。通过可拓性，我们想证明

foo f g n = f (g n)

其中，

f，g，n

是签名为

foo

的类型的原始值

f :: b -> c
g :: a -> b
n :: a

我们从相关的自由定理开始，它可以是：

让我们通过专门化来简化这个庞大的公式。我们选择：

t1 = a    t2 = ()
t3 = b    t4 = ()
t5 = c    t6 = ()

我们选择的关系如下：

R = { (n       , ()) }  which is indeed in REL(t1,t2) = REL(a,())
S = { (g n     , ()) }  which is indeed in REL(t3,t4) = REL(b,())
R1= { (f (g n) , ()) }  which is indeed in REL(t5,t6) = REL(c,())

自由定理变成：

   forall p :: b -> c.
    forall q :: () -> ().
     (forall (x, y) in S. (p x, q y) in R1)
     ==> (forall r :: a -> b.
           forall s :: () -> ().
            (forall (z, v) in R. (r z, s v) in S)
            ==> (forall (w, u) in R.
                  (foo p r w, foo q s u) in R1))

根据

S

和

R1

的定义，选择

p=f

和

q=id

：

     (forall x = g n, y = () . f x = f (g n) /\ y = id y)
     ==> (forall r :: a -> b.
           forall s :: () -> ().
            (forall (z, v) in R. (r z, s v) in S)
            ==> (forall (w, u) in R.
                  (foo f r w, foo id s u) in R1))

顶层含义的前提是真的，所以我们解除它。 现在我们选择

r=g

和

s=id

。根据

r1

和

R

的定义，我们得到：

            (forall z = n, v = () . g z = g n , id v = ())
            ==> (forall (w, u) in R.
                  (foo f g w, foo id id u) in R1)

我们可以实现真正的前提。此外，我们可以选择

w=n

和

u=（）

。我们最终获得：

                  foo f g n = f (g n) /\ foo id id u = ()

---

Q.E.D.

无意义是什么意思？它由两个功能组成。顺便说一句，这篇链接文章清楚地说明了这一点。@kraskevich已经更新了这个问题。它大大减少了函数foo的可能实现的数量-是否有一个实现与常规实现不同？@BartekBanachewicz-我不这么认为，我相信比我更有知识的人可以证明这一点。我相信

f=（）

之后应考虑相应命题的规范化自然演绎证明。或者可能是因为它的自由定理（尽管我只是快速尝试了一下失败）。@BartekBanachewicz

未定义的

，

\\\\\\\\\\>未定义的

，

\\\\\\\\\\\>未定义的

都具有给定的类型，并且在有意义的方面与常规类型不同。还有许多变体，如

\f->f`seq`\gx->f（gx）

，在不同的时间强制使用它们的参数。其中一些不仅不同，而且很有用。

            (forall z = n, v = () . g z = g n , id v = ())
            ==> (forall (w, u) in R.
                  (foo f g w, foo id id u) in R1)

                  foo f g n = f (g n) /\ foo id id u = ()