开始之前，先来简单回顾一下泛型编程的内容。
泛型编程的目的是将「数据和方法」进行分离，将数据高度抽象，于是可以表示同类问题的「最小通解」。
C++中，通过模板来实现泛型编程，模板又分为变量模板、函数模板和类模板。
这些模板始终围绕着「数据和方法」。变量模板属于对数据类型的抽象，函数模板属于对方法的抽象，而类模板，则二者兼有，因为类本身的目的就是将数据和方法进行结合。
因此为什么说函数模板处理的是数值，而类模板处理的是类型呢？就是由于函数只具有方法，而在C++中方法是不支持偏特化的，所以它无法处理类型。
到了C++14，Lambda也迎来了泛化能力，称为Generic Lambda。不过此时的泛化能力只是由auto带来的，威力略弱。
随后又经过多年的发展，Lambda的能力越来越强。C++20加入了Template Lambda，这让Lambda也可以指定模板参数，使得Lambda的泛化能力更加完善。
至此，C++的泛型编程多了一个新的主角——泛型Lambda。
为何泛型Lambda值得单独拿出来说呢？
一是因其特殊性，在一些情境使用它来封装变化，会让事情简单许多；二是由其新颖性，它的许多特性和用处尚处探索期，值得讨论。
首先来说其特殊性。
Lambda函数其实就是一个匿名的函数对象，它实际上也是一个”类”。不同的是，它唯一的方法就是operator()，也就是Lambda体，而数据则是[]中捕获的参数，这些参数就是”类”中定义的成员变量。
因此，Lambda函数既具有函数的部分特征，又具有类的部分特征。
也因如此，事情变得有趣起来。
Lambda具有的函数部分特征，让它具备了函数模板的能力；类部分特征，让它具备了类模板的继承能力。
此外，由于Lambda的类型是一个closure type（闭包类型），所以它还可以定义在函数内部，也可以当作回调函数使用。
如此这些，再加上泛型，使得泛型Lambda极具威力。
继而来看其新颖性。
当下大多数C++开发者对于Lambda的使用，还只是停留在函数部分，相当于只发挥了Lambda的基本能力。
实际上，Lambda的能力要比想象之中强大许多，在基本能力之上，还有些令人兴奋的能力。
这也是值得探索的地方。
不论写库或框架，都是在提炼「不变」的逻辑，将「变化」的逻辑交给用户配置。
可以是预留接口，让用户覆写接口；也可以是采用回调，让用户提供处理逻辑；抑或是提供配置文件，让用户填写变化的信息，再通过配置文件自动生成相应处理逻辑。
应对「变化」的方式很多，对于一些逻辑不甚复杂的变化，完全可以借助Lambda来实现。
Lambda天生可以在函数内部构建，自带一个operator ()，这就相当于一个表示变化的接口，也就是用户可以手动配置的地方。
有了表示变化的地方，你再将不变的逻辑封装到一个类中，让该类继承自此Lambda。于是，你便可以在不变之中使用变化的逻辑。
既然泛型Lambda具备函数模板的特性，那么它是否也可以重载呢？
回答是no。前文提到，Lambda是函数对象，它只有唯一的一个方法operator()，也就是Lambda体，Lambda体只有一个，你又如何能写多个呢？
但是，可以提供多个Lambda，也就是造就多个函数对象，让它们参数不同，再借助某种技巧，便可以从「视觉层面」实现Lambda重载。
说是「视觉层面」，意思是说它本质上不是函数意义上的那种重载，只是使用起来像是函数重载一样。
这个技巧就是overload pattern。
其实早在C++ DP.13-2 泛化实现Cyclic Visitor与强大的C++17 std::visit这篇文章中，就已经提到并使用了这个技巧。
这里再次拿出一节来介绍它，是因为我发现它比想象之中更加强大，可以说是泛型Lambda编程的一个核心技术。
它的实作很简单，只有两行代码:
1template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
2template<class... Ts> overloaded(Ts...) -> overloaded;
各位都知道，C++中代码越少往往并不意味着它有多简单，而是说明其「信息密度」较大。
此处，第一行首先使用了可变参数模板，使得overloaded可以继承自多个Lambda。其次使用了Using-declaration，以防止重载之时产生歧义。
第二行则使用了C++17的CTAD(Class Template Argument Deduction)，以推导出overloaded的类型。有何必要呢？这是因为你无法创建一个overloaded类型的对象，因为Lambda的类型不可知，你无法填写模板参数类型。借由CTAD，便可以为overloaded添加一个用户自定义的类型推导指引，这样编译器才能够推导出其类型。
现在，就可以使用「视觉层面」的Lambda重载了：
1const auto func = overloaded {
2 [](const int& n) { std::cout << "int:" << n << '\n'; },\
3 [](const std::string& s) { std::cout << "string:" << s << '\n'; }
4};
5
6func(2);
7func("im the lambda with parameter std::string");
这里又使用了「聚合初始化」，通过它可以直接调用基类中Lambda的构造器，从而避免为overloaded显式编写构造函数向基类传递参数。
总而言之，通过Lambda重载，便可以将许多相似的「变化逻辑」聚到一起，再以不同的参数访问这些不同的逻辑，从而以一种崭新的形式封装变化。
这一节需要你对C++ DP.08 Factory Method这篇文章有些印象。
通过泛型Lambda，我们拥有了一种新的实现对象工厂的策略，简单而威力巨大。
代码如下：
1template<class... Ts> struct Fruit : Ts... { using Ts::operator()...; };
2template<class... Ts> Fruit(Ts...) -> Fruit;
是的，就是使用了Lambda重载来实现Fruit。
然后再通过以下形式定义对象工厂：
1struct Apple { void print() { std::cout << "apple print\n"; } };
2struct Pineapplce {void print() { std::cout << "pineapple print\n"; } };
3
4// 定义对象工厂
5static constexpr auto FruitFactory = Fruit {
6 []<typename T>(const T& apple) { return new T; }
7};
8
9// 从工厂创建产品
10auto apple = FruitFactory(Apple{});
11apple->print();
此处第6行代码便使用了C++20的Template Lambda，由此我们可以创建任意类型的对象。
如此少的代码，实现的对象工厂可并不弱，而且这种实现方法更加轻便，除了无法动态产生，已经相当不错了。
这一节需要你对C++ DP.09 Abstract Factory这篇文章有些印象。
没错，根据泛型Lambda，实现抽象工厂也有了一种新的形式。
并且这种形式使用起来更加轻便，我已经决定使用这种方式替换okdp中的实现。
我们可以通过Lambda重载来定义抽象工厂：
1template<class... Ts> struct AbstractAIFactory : Ts... { using Ts::operator()...; };
2template<class... Ts> AbstractAIFactory(Ts...) -> AbstractAIFactory;
具体工厂的定义则更具有技巧性，实现如下：
