1 void Test_Type::TestMPL()
 2 {
 3     VL_UNITTEST_CHECK(ToString<Char<'A'>>::Eval()==L"\'A\'");
 4     VL_UNITTEST_CHECK(ToString<WChar<'A'>>::Eval()==L"L\'A\'");
 5     VL_UNITTEST_CHECK(ToString<Int<100>>::Eval()==L"100");
 6     VL_UNITTEST_CHECK(ToString<Bool<true>>::Eval()==L"true");
 7     VL_UNITTEST_CHECK(ToString<Bool<false>>::Eval()==L"false");
 8 
 9     VL_UNITTEST_CHECK((ToString<
10         Plus_<Int<1>,Int<2>>::Type
11         >::Eval()==L"3"));
12     VL_UNITTEST_CHECK((ToString<
13         Empty
14         >::Eval()==L"[]"));
15     VL_UNITTEST_CHECK((ToString<
16         List<Char<'A'>,List<Char<'B'>,List<Char<'C'>,Empty>>>
17         >::Eval()==L"[\'A\' , \'B\' , \'C\']"));
18     VL_UNITTEST_CHECK((ToString<
19         List<Int<0>,List<Int<1>,List<Int<2>,Empty>>>
20         >::Eval()==L"[0 , 1 , 2]"));
21 
22 typedef Iterate_<Bind2<Plus,Int<1>>,Int<0>,Int<3>>::Type LIST_012;
23 typedef Iterate_<Bind2<Plus,Int<1>>,Int<3>,Int<3>>::Type LIST_345;
24 typedef Iterate_<Bind2<Plus,Int<1>>,Int<1>,Int<10>>::Type LONG_LIST;
25 
26     VL_UNITTEST_CHECK((ToString<
27         Reverse_<LIST_012>::Type
28         >::Eval()==L"[2 , 1 , 0]"));
29 
30     VL_UNITTEST_CHECK((ToString<
31         Concat_<LIST_012,LIST_345>::Type
32         >::Eval()==L"[0 , 1 , 2 , 3 , 4 , 5]"));
33 
34     VL_UNITTEST_CHECK((ToString<
35         Filter_<Bind2<RevOp<Egt>,Int<2>>,Concat_<LIST_012,LIST_345>>::Type
36         >::Eval()==L"[2 , 3 , 4 , 5]"));
37 
38     VL_UNITTEST_CHECK((ToString<
39         Transform_<Bind2<Multiply,Int<2>>,Concat_<LIST_012,LIST_345>>::Type
40         >::Eval()==L"[0 , 2 , 4 , 6 , 8 , 10]"));
41 
42     VL_UNITTEST_CHECK((ToString<
43         Transform_<Sqr,Concat_<LIST_012,LIST_345>>::Type
44         >::Eval()==L"[0 , 1 , 4 , 9 , 16 , 25]"));
45 
46     VL_UNITTEST_CHECK((ToString<
47         Foldl_<Plus,Int<0>,LONG_LIST>::Type
48         >::Eval()==L"55"));
49 
50     VL_UNITTEST_CHECK((ToString<
51         Foldr_<Plus,Int<0>,LONG_LIST>::Type
52         >::Eval()==L"55"));
53 
54     VL_UNITTEST_CHECK((ToString<
55         Foldl_<Minus,Int<0>,LONG_LIST>::Type
56         >::Eval()==L"-55"));
57 
58     VL_UNITTEST_CHECK((ToString<
59         Foldr_<Minus,Int<0>,LONG_LIST>::Type
60         >::Eval()==L"-5"));
61 
62     VL_UNITTEST_CHECK((ToString<
63         Foldl_<Plus,Int<0>,Take_<LONG_LIST,Int<9>>>::Type
64         >::Eval()==L"45"));
65 
66     VL_UNITTEST_CHECK((ToString<
67         Foldl_<Plus,Int<0>,Drop_<LONG_LIST,Int<1>>>::Type
68         >::Eval()==L"54"));
69 }

  1 /*******************************************************************************
  2 Vczh Library++ 2.0
  3 数据结构::元编程
  4 开发者：陈梓瀚
  5 
  6 函数：
  7   Plus
  8   Minus
  9   Multiply
 10   Divid
 11   Mod
 12   Neg
 13   Sqr
 14   And
 15   Or
 16   Xor
 17   Not
 18   Equ
 19   Neq
 20   Lt
 21   Gt
 22   Elt
 23   Egt
 24   If
 25   IsEmpty
 26   Head
 27   Tail
 28   Concat
 29   Reverse
 30   Filter
 31   Transform
 32   Foldl
 33   Foldr
 34   Take
 35   Drop
 36   Count
 37   Iterate
 38 *******************************************************************************/
 39 
 40 #ifndef VL_MPL
 41 #define VL_MPL
 42 
 43 #include "..\Data\VL_Data_String.h"
 44 
 45 namespace vl
 46 {
 47     namespace mp
 48     {
 49 
 50 /*********************************************************************************************************
 51 数值
 52 *********************************************************************************************************/
 53 
 54         template<char V>
 55         struct Char
 56         {
 57             static const char Value=V;
 58             typedef Char<V> Type;
 59         };
 60 
 61         template<wchar_t V>
 62         struct WChar
 63         {
 64             static const wchar_t Value=V;
 65             typedef WChar<V> Type;
 66         };
 67 
 68         template<int V>
 69         struct Int
 70         {
 71             static const int Value=V;
 72             typedef Int<V> Type;
 73         };
 74 
 75         template<bool V>
 76         struct Bool
 77         {
 78             static const bool Value=V;
 79             typedef Bool<V> Type;
 80         };
 81 
 82         struct Empty
 83         {
 84             typedef Empty Type;
 85         };
 86 
 87         template<typename H , typename T>
 88         struct List
 89         {
 90             typedef List<H,T> Type;
 91         };
 92 
 93 /*********************************************************************************************************
 94 函数调用
 95 *********************************************************************************************************/
 96 
 97         template<typename F , typename A>
 98         struct Apply
 99         {
100             typedef typename F::Apply<typename A::Type>::Type Type;
101         };
102 
103         template<typename F , typename A , typename B>
104         struct Apply2
105         {
106             typedef typename F::Apply2<typename A::Type,typename B::Type>::Type Type;
107         };
108 
109         template<typename F , typename A , typename B , typename C>
110         struct Apply3
111         {
112             typedef typename F::Apply3<typename A::Type,typename B::Type,typename C::Type>::Type Type;
113         };
114 
115         template<typename F , typename A , typename B , typename C , typename D>
116         struct Apply4
117         {
118             typedef typename F::Apply4<typename A::Type,typename B::Type,typename C::Type,typename D::Type>::Type Type;
119         };
120 
121         template<typename F , typename A , typename B , typename C , typename D , typename E>
122         struct Apply5
123         {
124             typedef typename F::Apply5<typename A::Type,typename B::Type,typename C::Type,typename D::Type,typename E::Type>::Type Type;
125         };
126 
127 #define MPL_PACK(NAME)    template<typename A>                                                    struct NAME##_{typedef typename mp::Apply<NAME,A>::Type Type;}
128 #define MPL_PACK2(NAME)    template<typename A , typename B>                                        struct NAME##_{typedef typename mp::Apply2<NAME,A,B>::Type Type;}
129 #define MPL_PACK3(NAME)    template<typename A , typename B , typename C>                            struct NAME##_{typedef typename mp::Apply3<NAME,A,B,C>::Type Type;}
130 #define MPL_PACK4(NAME)    template<typename A , typename B , typename C , typename D>                struct NAME##_{typedef typename mp::Apply4<NAME,A,B,C,D>::Type Type;}
131 #define MPL_PACK5(NAME)    template<typename A , typename B , typename C , typename D , typename E>struct NAME##_{typedef typename mp::Apply5<NAME,A,B,C,D,E>::Type Type;}
132 #define MPL_PRINT_TO_ERROR(NAME) do{typedef NAME Type;typedef NAME::WRONG_TYPE WRONG_TYPE;}while(0)
133 
134 /*********************************************************************************************************
135 绑定器
136 *********************************************************************************************************/
137 
138         template<typename F , typename P>
139         struct Bind2
140         {
141             template<typename P1>
142             struct Apply
143             {
144                 typedef typename mp::Apply2<F,P,P1>::Type Type;
145             };
146 
147             typedef Bind2<F,P> Type;
148         };
149 
150         template<typename F , typename P>
151         struct Bind3
152         {
153             template<typename P1 , typename P2>
154             struct Apply2
155             {
156                 typedef typename mp::Apply3<F,P,P1,P2>::Type Type;
157             };
158 
159             typedef Bind3<F,P> Type;
160         };
161 
162         template<typename F , typename P>
163         struct Bind4
164         {
165             template<typename P1 , typename P2 , typename P3>
166             struct Apply3
167             {
168                 typedef typename mp::Apply4<F,P,P1,P2,P3>::Type Type;
169             };
170 
171             typedef Bind4<F,P> Type;
172         };
173 
174         template<typename F , typename P>
175         struct Bind5
176         {
177             template<typename P1 , typename P2 , typename P3 , typename P4>
178             struct Apply4
179             {
180                 typedef typename mp::Apply5<F,P,P1,P2,P3,P4>::Type Type;
181             };
182 
183             typedef Bind5<F,P> Type;
184         };
185 
186         template<typename F>
187         struct RevOp
188         {
189             template<typename P1 , typename P2>
190             struct Apply2
191             {
192                 typedef typename mp::Apply2<F,P2,P1>::Type Type;
193             };
194 
195             typedef RevOp<F> Type;
196         };
197 
198 /*********************************************************************************************************
199 基本函数
200 *********************************************************************************************************/
201 
202         struct Plus
203         {
204             template<typename A , typename B>
205             struct Apply2
206             {
207             };
208 
209             template<int A , int B>
210             struct Apply2<Int<A> , Int<B>>
211             {
212                 typedef Int<A+B> Type;
213             };
214 
215             typedef Plus Type;
216         };
217         MPL_PACK2(Plus);
218 
219         struct Minus
220         {
221             template<typename A , typename B>
222             struct Apply2
223             {
224             };
225 
226             template<int A , int B>
227             struct Apply2<Int<A> , Int<B>>
228             {
229                 typedef Int<A-B> Type;
230             };
231 
232             typedef Minus Type;
233         };
234         MPL_PACK2(Minus);
235 
236         struct Multiply
237         {
238             template<typename A , typename B>
239             struct Apply2
240             {
241             };
242 
243             template<int A , int B>
244             struct Apply2<Int<A> , Int<B>>
245             {
246                 typedef Int<A*B> Type;
247             };
248 
249             typedef Multiply Type;
250         };
251         MPL_PACK2(Multiply);
252 
253         struct Divid
254         {
255             template<typename A , typename B>
256             struct Apply2
257             {
258             };
259 
260             template<int A , int B>
261             struct Apply2<Int<A> , Int<B>>
262             {
263                 typedef Int<A/B> Type;
264             };
265 
266             typedef Divid Type;
267         };
268         MPL_PACK2(Divid);
269 
270         struct Mod
271         {
272             template<typename A , typename B>
273             struct Apply2
274             {
275             };
276 
277             template<int A , int B>
278             struct Apply2<Int<A> , Int<B>>
279             {
280                 typedef Int<A%B> Type;
281             };
282 
283             typedef Mod Type;
284         };
285         MPL_PACK2(Mod);
286 
287         struct Neg
288         {
289             template<typename A>
290             struct Apply
291             {
292             };
293 
294             template<int A>
295             struct Apply<Int<A>>
296             {
297                 typedef Int<-A> Type;
298             };
299 
300             typedef Neg Type;
301         };
302         MPL_PACK(Neg);
303 
304         struct Sqr
305         {
306             template<typename A>
307             struct Apply
308             {
309             };
310 
311             template<int A>
312             struct Apply<Int<A>>
313             {
314                 typedef Int<A*A> Type;
315             };
316 
317             typedef Sqr Type;
318         };
319         MPL_PACK(Sqr);
320 
321         struct And
322         {
323             template<typename A , typename B>
324             struct Apply2
325             {
326             };
327             
328             template<bool A , bool B>
329             struct Apply2<Bool<A> , Bool<B>>
330             {
331                 typedef Bool<A&&B> Type;
332             };
333 
334             typedef And Type;
335         };
336         MPL_PACK2(And);
337 
338         struct Or
339         {
340             template<typename A , typename B>
341             struct Apply2
342             {
343             };
344             
345             template<bool A , bool B>
346             struct Apply2<Bool<A> , Bool<B>>
347             {
348                 typedef Bool<A||B> Type;
349             };
350 
351             typedef Or Type;
352         };
353         MPL_PACK2(Or);
354 
355         struct Xor
356         {
357             template<typename A , typename B>
358             struct Apply2
359             {
360             };
361             
362             template<bool A , bool B>
363             struct Apply2<Bool<A> , Bool<B>>
364             {
365                 typedef Bool<A^B> Type;
366             };
367 
368             typedef Xor Type;
369         };
370         MPL_PACK2(Xor);
371 
372         struct Not
373         {
374             template<typename A>
375             struct Apply
376             {
377             };
378             
379             template<bool A>
380             struct Apply<Bool<A>>
381             {
382                 typedef Bool<!A> Type;
383             };
384 
385             typedef Not Type;
386         };
387         MPL_PACK(Not);
388 
389         struct Equ
390         {
391             template<typename A , typename B>
392             struct Apply2
393             {
394                 typedef Bool<false> Type;
395             };
396 
397             template<typename A>
398             struct Apply2<A , A>
399             {
400                 typedef Bool<true> Type;
401             };
402 
403             typedef Equ Type;
404         };
405         MPL_PACK2(Equ);
406 
407         struct Neq
408         {
409             template<typename A , typename B>
410             struct Apply2
411             {
412                 typedef typename Not_<Equ_<A,B>>::Type Type;
413             };
414 
415             typedef Neq Type;
416         };
417         MPL_PACK2(Neq);
418 
419         struct Lt
420         {
421             template<typename A , typename B>
422             struct Apply2
423             {
424             };
425 
426             template<char A , char B>
427             struct Apply2<Char<A> , Char<B>>
428             {
429                 typedef Bool<(A<B)> Type;
430             };
431 
432             template<wchar_t A , wchar_t B>
433             struct Apply2<WChar<A> , WChar<B>>
434             {
435                 typedef Bool<(A<B)> Type;
436             };
437 
438             template<int A , int B>
439             struct Apply2<Int<A> , Int<B>>
440             {
441                 typedef Bool<(A<B)> Type;
442             };
443 
444             typedef Lt Type;
445         };
446         MPL_PACK2(Lt);
447 
448         struct Gt
449         {
450             template<typename A , typename B>
451             struct Apply2
452             {
453                 typedef typename Not_<Or_<Lt_<A,B>,Equ_<A,B>>>::Type Type;
454             };
455 
456             typedef Gt Type;
457         };
458         MPL_PACK2(Gt);
459 
460         struct Elt
461         {
462             template<typename A , typename B>
463             struct Apply2
464             {
465                 typedef typename Not_<Gt_<A,B>>::Type Type;
466             };
467 
468             typedef Elt Type;
469         };
470         MPL_PACK2(Elt);
471 
472         struct Egt
473         {
474             template<typename A , typename B>
475             struct Apply2
476             {
477                 typedef typename Not_<Lt_<A,B>>::Type Type;
478             };
479 
480             typedef Egt Type;
481         };
482         MPL_PACK2(Egt);
483 
484         struct If
485         {
486             template<typename A , typename B , typename C>
487             struct Apply3
488             {
489             };
490 
491             template<typename A , typename B>
492             struct Apply3<Bool<true> , A , B>
493             {
494                 typedef A Type;
495             };
496 
497             template<typename A , typename B>
498             struct Apply3<Bool<false> , A , B>
499             {
500                 typedef B Type;
501             };
502 
503             typedef If Type;
504         };
505         MPL_PACK3(If);
506 
507 /*********************************************************************************************************
508 列表操作
509 *********************************************************************************************************/
510 
511         struct IsEmpty
512         {
513             template<typename A>
514             struct Apply
515             {
516             };
517 
518             template<>
519             struct Apply<Empty>
520             {
521                 typedef Bool<true> Type;
522             };
523 
524             template<typename H , typename T>
525             struct Apply<List<H,T>>
526             {
527                 typedef Bool<false> Type;
528             };
529 
530             typedef IsEmpty Type;
531         };
532         MPL_PACK(Empty);
533 
534         struct Head
535         {
536             template<typename A>
537             struct Apply
538             {
539             };
540 
541             template<typename H , typename T>
542             struct Apply<List<H,T>>
543             {
544                 typedef H Type;
545             };
546 
547             typedef Head Type;
548         };
549         MPL_PACK(Head);
550 
551         struct Tail
552         {
553             template<typename A>
554             struct Apply
555             {
556             };
557 
558             template<typename H , typename T>
559             struct Apply<List<H,T>>
560             {
561                 typedef T Type;
562             };
563 
564             typedef Tail Type;
565         };
566         MPL_PACK(Tail);
567 
568         struct Concat
569         {
570             template<typename A , typename B>
571             struct Apply2
572             {
573             };
574 
575             template<>
576             struct Apply2<Empty,Empty>
577             {
578                 typedef Empty Type;
579             };
580 
581             template<typename H2 , typename T2>
582             struct Apply2<Empty,List<H2,T2>>
583             {
584                 typedef List<H2,T2> Type;
585             };
586 
587             template<typename H1 , typename T1>
588             struct Apply2<List<H1,T1>,Empty>
589             {
590                 typedef List<H1,T1> Type;
591             };
592 
593             template<typename H1 , typename T1 , typename H2 , typename T2>
594             struct Apply2<List<H1,T1>,List<H2,T2>>
595             {
596                 typedef List<H1,typename mp::Apply2<Concat,T1,List<H2,T2>>::Type> Type;
597             };
598 
599             typedef Concat Type;
600         };
601         MPL_PACK2(Concat);
602 
603         struct Reverse
604         {
605             template<typename A>
606             struct Apply
607             {
608             };
609 
610             template<>
611             struct Apply<Empty>
612             {
613                 typedef Empty Type;
614             };
615 
616             template<typename H>
617             struct Apply<List<H,Empty>>
618             {
619                 typedef List<H,Empty> Type;
620             };
621 
622             template<typename H , typename T>
623             struct Apply<List<H,T>>
624             {
625                 typedef typename Concat_<mp::Apply<Reverse,T>,List<H,Empty>>::Type Type;
626             };
627 
628             typedef Reverse Type;
629         };
630         MPL_PACK(Reverse);
631 
632         struct Filter
633         {
634             template<typename A , typename B>
635             struct Apply2
636             {
637             };
638 
639             template<typename F>
640             struct Apply2<F,Empty>
641             {
642                 typedef Empty Type;
643             };
644 
645             template<typename F , typename H , typename T>
646             struct Apply2<F,List<H,T>>
647             {
648                 typedef
649                     typename If_<
650                         mp::Apply<F,H>,
651                         List<H,typename mp::Apply2<Filter,F,T>::Type>,
652                         mp::Apply2<Filter,F,T>
653                     >::Type Type;
654             };
655 
656             typedef Filter Type;
657         };
658         MPL_PACK2(Filter);
659 
660         struct Transform
661         {
662             template<typename A , typename B>
663             struct Apply2
664             {
665             };
666 
667             template<typename F>
668             struct Apply2<F,Empty>
669             {
670                 typedef Empty Type;
671             };
672 
673             template<typename F , typename H , typename T>
674             struct Apply2<F,List<H,T>>
675             {
676                 typedef List<typename mp::Apply<F,H>::Type,typename mp::Apply2<Transform,F,T>::Type> Type;
677             };
678 
679             typedef Transform Type;
680         };
681         MPL_PACK2(Transform);
682 
683         struct Foldl
684         {
685             template<typename A , typename B , typename C>
686             struct Apply3
687             {
688             };
689 
690             template<typename F , typename I>
691             struct Apply3<F,I,Empty>
692             {
693                 typedef I Type;
694             };
695 
696             template<typename F , typename I , typename H , typename T>
697             struct Apply3<F,I,List<H,T>>
698             {
699                 typedef typename mp::Apply3<Foldl,F,mp::Apply2<F,I,H>,T>::Type Type;
700             };
701 
702             typedef Foldl Type;
703         };
704         MPL_PACK3(Foldl);
705 
706         struct Foldr
707         {
708             template<typename A , typename B , typename C>
709             struct Apply3
710             {
711             };
712 
713             template<typename F , typename I>
714             struct Apply3<F,I,Empty>
715             {
716                 typedef I Type;
717             };
718 
719             template<typename F , typename I , typename H , typename T>
720             struct Apply3<F,I,List<H,T>>
721             {
722                 typedef typename mp::Apply2<F,H,mp::Apply3<Foldr,F,I,T>>::Type Type;
723             };
724 
725             typedef Foldr Type;
726         };
727         MPL_PACK3(Foldr);
728 
729         struct Take
730         {
731             template<typename A , typename B>
732             struct Apply2
733             {
734             };
735 
736             template<>
737             struct Apply2<Empty,Int<0>>
738             {
739                 typedef Empty Type;
740             };
741 
742             template<int I>
743             struct Apply2<Empty,Int<I>>
744             {
745                 typedef Empty Type;
746             };
747 
748             template<typename H , typename T>
749             struct Apply2<List<H,T>,Int<0>>
750             {
751                 typedef Empty Type;
752             };
753 
754             template<typename H , typename T , int I>
755             struct Apply2<List<H,T>,Int<I>>
756             {
757                 typedef List<H,typename mp::Apply2<Take,T,Int<I-1>>::Type> Type;
758             };
759 
760             typedef Take Type;
761         };
762         MPL_PACK2(Take);
763 
764         struct Drop
765         {
766             template<typename A , typename B>
767             struct Apply2
768             {
769             };
770 
771             template<>
772             struct Apply2<Empty,Int<0>>
773             {
774                 typedef Empty Type;
775             };
776 
777             template<int I>
778             struct Apply2<Empty,Int<I>>
779             {
780                 typedef Empty Type;
781             };
782 
783             template<typename H , typename T>
784             struct Apply2<List<H,T>,Int<0>>
785             {
786                 typedef List<H,T> Type;
787             };
788 
789             template<typename H , typename T , int I>
790             struct Apply2<List<H,T>,Int<I>>
791             {
792                 typedef typename mp::Apply2<Drop,T,Int<I-1>>::Type Type;
793             };
794 
795             typedef Drop Type;
796         };
797         MPL_PACK2(Drop);
798 
799         struct Count
800         {
801             template<typename A>
802             struct Apply
803             {
804             };
805 
806             template<>
807             struct Apply<Empty>
808             {
809                 typedef Int<0> Type;
810             };
811 
812             template<typename H , typename T>
813             struct Apply<List<H,T>>
814             {
815                 typedef typename Plus_<Int<1>,mp::Apply<Count,T>>::Type Type;
816             };
817 
818             typedef Count Type;
819         };
820         MPL_PACK(Count);
821 
822         struct Iterate
823         {
824             struct Iterate_Internal
825             {
826                 template<typename A , typename B , typename C , typename D>
827                 struct Apply4
828                 {
829                 };
830 
831                 template<typename F , typename L , typename V>
832                 struct Apply4<F,L,V,Int<0>>
833                 {
834                     typedef L Type;
835                 };
836 
837                 template<typename F , typename L , typename V , int I>
838                 struct Apply4<F,L,V,Int<I>>
839                 {
840                     typedef typename mp::Apply4<Iterate_Internal,F,Concat_<L,List<V,Empty>>,mp::Apply<F,V>,Int<I-1>>::Type Type;
841                 };
842             };
843 
844             template<typename F , typename V , typename C>
845             struct Apply3
846             {
847                 typedef typename mp::Apply4<Iterate_Internal,F,Empty,V,C>::Type Type;
848             };
849 
850             typedef Iterate Type;
851         };
852         MPL_PACK3(Iterate);
853 
854 /*********************************************************************************************************
855 转字符串
856 *********************************************************************************************************/
857 
858         template<typename T>
859         struct ToString
860         {
861             static VUnicodeString Eval()
862             {
863                 return L"";
864             }
865         };
866 
867         template<bool V>
868         struct ToString<Bool<V>>
869         {
870             static VUnicodeString Eval()
871             {
872                 return V?L"true":L"false";
873             }
874         };
875 
876         template<char V>
877         struct ToString<Char<V>>
878         {
879             static VUnicodeString Eval()
880             {
881                 return L"\'"+VUnicodeString(ToUnicode(V))+L"\'";
882             }
883         };
884 
885         template<wchar_t V>
886         struct ToString<WChar<V>>
887         {
888             static VUnicodeString Eval()
889             {
890                 return L"L\'"+VUnicodeString(V)+L"\'";
891             }
892         };
893 
894         template<int V>
895         struct ToString<Int<V>>
896         {
897             static VUnicodeString Eval()
898             {
899                 return V;
900             }
901         };
902 
903         template<>
904         struct ToString<Empty>
905         {
906             static VUnicodeString Eval()
907             {
908                 return L"[]";
909             }
910         };
911 
912         template<typename H>
913         struct ToString<List<H,Empty>>
914         {
915             static VUnicodeString Eval()
916             {
917                 return L"["+ToString<H>::Eval()+L"]";
918             }
919         };
920 
921         template<typename H , typename T>
922         struct ToString<List<H,T>>
923         {
924             static VUnicodeString Eval()
925             {
926                 VUnicodeString Tail=ToString<T>::Eval();
927                 Tail.Delete(0,1);
928                 return L"["+ToString<H>::Eval()+L" , "+Tail;
929             }
930         };
931     }
932 }
933 
934 #endif