Question

我在C ++中编写了一个匿名因子函数，并使用g ++ 4.9.2编译了我的代码。它运作良好。但是，我不知道我的功能类型。

#include<iostream>
#include<functional>
using std::function;
int main()
{
    //tested at g++ 4.9.2
    //g++ -std=c++1y -o anony anony.cpp
    auto fac = [](auto self,auto n)->auto{
        if(n < 1)
            return 1;
        else 
            return n * self(self,n-1);
    };
    std::cout<<fac(fac,3)<<std::endl;//6
    return 0;
}

所以，我想知道：fac和self的类型是什么？如果我只是将C ++代码翻译成Haskell，它将无法编译，因为它涉及无限类型：

fac2 self 0 = 1
fac2 self n = n * (self self $ n-1)

我必须定义一些递归类型的工作：

data Y a = Y ((Y a)->a->a)
fac2 self 0 = 1
fac2 self n = n * ((applY self self) (n-1))
    where applY (Y f1) f2 = f1 f2
fact2 = fac2 $ Y fac2

那么，为什么g ++能够得到fac函数的正确类型，g ++认为fac函数的类型是什么？

Answer 1

C ++ fac并不是一个真正的函数，而是一个具有成员函数的结构。

struct aaaa // Not its real name.
{
    template<typename a, typename b>
    auto operator()(a self, b n) const
    { 
    }
};

重载的调用操作符隐藏了C ++执行的一些技巧，以实现＆＃34; lambda函数＆＃34;

当你＆＃34;打电话＆＃34; fac，会发生什么

fac.operator() (fac, 3);

所以函数的参数不是函数本身，而是一个将它作为成员的对象。
这样做的一个结果是函数的类型（即operator()的类型）不会出现在operator()函数本身的类型中。
（self的类型是定义函数的结构。）

模板部分不是必须的;这是fac＆＃34;函数的非泛型版本＆＃34;：

struct F
{
    int operator()(const F& self, int n) const
    { 
        // ...
    }
};

F fac;
fac(fac, 3);

如果我们保留模板并将operator()重命名为applY：

// The Y type
template<typename a>
struct Y
{
    // The wrapped function has type (Y<a>, a) -> a
    a applY(const Y<a>& self, a n) const
    { 
        if(n < 1)
            return 1;
        else 
            return n * self.applY(self, n-1);
    }
};

template<typename a>
a fac(a n)
{
    Y<a> y;
    return y.applY(y, n);
}

我们看到你工作的Haskell程序和你的C ++程序非常相似 - 差异主要是标点符号。

相反，在Haskell中

fac2 self 0 = 1
fac2 self n = n * (self self $ n-1)

self 是一个函数，而fac2的类型必须是

X -> Int -> Int

某些X

由于self是一个函数，self self $ n-1是一个Int，self的类型也是X -> Int -> Int。

但X可能是什么？它必须与self本身的类型相同，即X -> Int -> Int 但这意味着self的类型是（代替X）：

(X -> Int -> Int) -> Int -> Int

所以类型X也必须是

(X -> Int -> Int) -> Int -> Int

所以self的类型必须是

((X -> Int -> Int) -> Int -> Int) -> Int -> Int

依此类推，无限无休也就是说，在Haskell中，类型将是无限的。

您对Haskell的解决方案基本上明确地介绍了C ++通过其结构和成员函数生成的必要间接。

Answer 2

正如其他人所指出的，lambda充当涉及模板的结构。那么问题就变成了：为什么Haskell不能输入自我应用程序，而C ++可以？

答案取决于C ++模板和Haskell多态函数之间的区别。比较这些：

-- valid Haskell
foo :: forall a b. a -> b -> a
foo x y = x

// valid C++
template <typename a, typename b>
a foo(a x, b y) { return x; }

虽然它们看起来几乎相同，但实际上并非如此。

当Haskell类型检查上述声明时，它会检查该定义对于任何类型a,b是否类型安全。也就是说，如果我们用任何两种类型替换a,b，那么函数必须是明确定义的。

C ++遵循另一种方法。在模板定义时，不会检查a,b的任何替换是否正确。该检查延迟到模板的使用点，即在实例化时。为了强调这一点，我们在代码中添加+1：

-- INVALID Haskell
foo :: forall a b. a -> b -> a
foo x y = x+1

// valid C++
template <typename a, typename b>
a foo(a x, b y) { return x+1; }

Haskell定义不会进行类型检查：当x+1属于任意类型时，不保证可以执行x。相反，C ++代码很好。 a的某些替换导致错误代码的事实现在无关紧要。

推迟此检查会导致一些＆＃34;无限类型的值＆＃34;大致允许。诸如Python或Scheme之类的动态语言会将这些类型错误推迟到运行时，当然也会处理自我应用程序。

Answer 3

auto fac =之后的表达式是一个lambda表达式，编译器将自动从中生成一个闭包对象。该对象的类型是唯一的，只有编译器知道。

来自N4296，§5.1.2/ 3 [expr.prim.lambda]

lambda-expression 的类型（也是闭包对象的类型）是一个唯一的，未命名的非联合类类型 - 称为闭包类型 - 其属性如下所述。此类类型既不是聚合（8.5.1）也不是文字类型（3.9）。闭包类型在包含相应 lambda-expression 的最小块作用域，类作用域或命名空间作用域中声明。

请注意，因此，即使两个相同的lambda表达式也会有不同的类型。例如，

auto l1 = []{};
auto l2 = []{}; // l1 and l2 are of different types

您的lambda表达式是C ++ 14泛型lambda，并将由编译器转换为类似于以下内容的类：

struct __unique_name
{
    template<typename Arg1, typename Arg2>
    auto operator()(Arg1 self, Arg2 n) const
    { 
        // body of your lambda
    }
};

我无法评论Haskell部分，但递归表达式在C ++中工作的原因是因为您只是在每次调用中传递闭包对象实例（fac）的副本。作为模板的operator()能够推断出lambda的类型，即使它不是你可以命名的那个。

这种自适应因子函数的类型是什么？

3 个答案: