C++模板元编程 - 2 模仿haskell的列表以及相关操作

这是昨天和今天写的东西，利用C++的可变模板参数包以及包展开，模式匹配的一些东西做的，感觉用typename...比轮子叔那个List<A,List<B, List<C, D>>>的设计要好看不少。

List有一个很巧妙的继承，只有那么做才能使用类似于List<>::Rest的写法，直接定义成template<typename T, typename... TArgs>List是不行的。

Change这里可以给一个args...换另一个包装，这里感谢lyp菊苣告诉我原来template里还能接着套template，为我自己瞎摸索TML的道路开拓了另一片新天地。

scanf和foldl的原理大致基本相同，但是以我的智商是没法在短时间内把他们统一到一起了。

PrintList似乎只能使用函数来输出了。

写着写着也发现自己的模板元编程的编码和命名风格在不断完善，果然要不停写才能体会到东西。

（话说默认字体大小怎么改啊，13px才好看嘛）

 template<typename T>
 struct ListGet;
 template<typename... TArgs>
 struct List;
 
 template<typename T, typename... TArgs>
 struct ListGet<List<T, TArgs...>>
 {
     using First = typename T;
     using Rest = List<TArgs...>;
 };
 
 template<typename... TArgs>
 struct List: ListGet<List<TArgs...>>
 {
     using Base = ListGet<List<TArgs...>>;
     using Self = List<TArgs...>;
 };
 
 template<typename T>
 struct ListIsEmpty;
 
 template<typename T, typename... TArgs>
 struct ListIsEmpty<List<T, TArgs...>>
 {
     using Result = Bool<false>;
 };
 template<>
 struct ListIsEmpty<List<>>
 {
     using Result = Bool<true>;
 };
 
 template<typename A, template<typename... Args> typename B>
 struct Change;
 
 template<template<typename... Args>typename A, template<typename... Args>typename B, typename... Args>
 struct Change<A<Args...>, B>
 {
     using Result = B<Args...>;
 };
 
 template<typename T1, typename T2>
 struct ListConnect;
 
 template<typename... TArgs1, typename... TArgs2>
 struct ListConnect<List<TArgs1...>, List<TArgs2...>>
 {
     using Result = typename List<TArgs1..., TArgs2...>;
 };
 template<typename T>
 struct ListReverse;
 
 template<typename... TArgs>
 struct ListReverse<List<TArgs...>>
 {
     using Param = typename List<TArgs...>;
     using Result = typename ListConnect<
         typename ListReverse<
             typename Param::Rest
         >::Result,
         typename List<typename Param::First>
     >::Result;
 };
 
 template<typename T>
 struct ListReverse<List<T>>
 {
     using Result = typename List<T>;
 };
 
 template<template<typename ST> typename TApplicative, typename T1>
 struct ListMap;
 
 template<template<typename ST> typename TApplicative, typename... TArgs>
 struct ListMap<TApplicative, List<TArgs...>>
 {
     using Param = typename List<TArgs...>;
     using Result = typename ListConnect<
         List<
             typename TApplicative<
                 typename Param::First
             >::Result
         >,
         typename ListMap<
             TApplicative,
             typename Param::Rest
         >::Result
     >::Result;
 };
 
 template<template<typename ST> typename TApplicative, typename TLast>
 struct ListMap<TApplicative, List<TLast>>
 {
     using Param = typename List<TLast>;
     using Result = typename List<typename TApplicative<TLast>::Result>;
 };
 
 template<typename TVal, template<typename TArg1, typename TArg2> typename TBinFunc, typename T>
 struct ListFoldLeft;
 
 template<typename TVal, template<typename TArg1, typename TArg2> typename TBinFunc, typename... TArgs>
 struct ListFoldLeft<TVal, TBinFunc, List<TArgs...>>
 {
     using Param = List<TArgs...>;
     using Result = typename ListFoldLeft<
         typename TBinFunc<
             TVal,
             typename Param::First
         >::Result,
         TBinFunc,
         typename Param::Rest
     >::Result;
 };
 
 template<typename TVal, template<typename TArg1, typename TArg2> typename TBinFunc, typename TLast>
 struct ListFoldLeft<TVal, TBinFunc, List<TLast>>
 {
     using Param = List<TLast>;
     using Result = typename TBinFunc<TVal, typename Param::First>::Result;
 };
 
 template<typename TVal, template<typename TArg1, typename TArg2> typename TBinFunc, typename T>
 struct ListScanLeft;
 
 template<typename TVal, template<typename TArg1, typename TArg2> typename TBinFunc, typename... TArgs>
 struct ListScanLeft<TVal, TBinFunc, List<TArgs...>>
 {
     using Param = List<TArgs...>;
     using Value = typename TBinFunc<
         TVal,
         typename Param::First
     >::Result;
     using Result = typename ListConnect<
         List<Value>,
         typename ListScanLeft<
             Value,
             TBinFunc,
             typename Param::Rest
         >::Result
     >::Result;
 };
 
 template<typename TVal, template<typename TArg1, typename TArg2> typename TBinFunc, typename TLast>
 struct ListScanLeft<TVal, TBinFunc, List<TLast>>
 {
     using Param = List<TLast>;
     using Value = typename TBinFunc<
         TVal,
         typename Param::First
     >::Result;
     using Result = List<Value>;
 };
 
 template<typename T, T V, typename... TRest>
 void PrintList(List<PODType<T, V>, TRest...>)
 {
     std::cout << V << ' ';
     PrintList(List<TRest...>());
 }
 
 template<typename T, T V>
 void PrintList(List<PODType<T, V>>)
 {
     std::cout << V;
 }

（果然只有静态高亮的C++代码看上去就和翔一样）

使用起来是这样的

 List<Int<>, Int<>, Int<>, Int<>> list;
 ListFoldLeft<Int<>, Add, decltype(list)>::Result xxx;
 ListScanLeft<Int<>, Add, decltype(list)>::Result yyy;
 PrintList(yyy);

foldl1,foldr,foldr1以及对应的scanr……啊啊啊啊啊啊啊啊啊

 int main()
 {
     cout << L"我 整 个 人 都 递 归 了 ！ ！ ！ ！ ！ ！ 感 觉 自 己 充 满 了 力 量 ！ ！ ！ ！ ！ ！“;
     main();
 }