├── .gitignore
├── MetaLisp.hpp
├── README.md
└── examples
    ├── MetaLisp.xcodeproj
        └── project.pbxproj
    ├── factorial.hpp
    ├── huffman.hpp
    ├── main.cpp
    ├── queen.hpp
    └── sqrt.hpp


/.gitignore:
--------------------------------------------------------------------------------
1 | 
2 | # Xcode
3 | .DS_Store
4 | *.xcworkspace
5 | xcuserdata
6 | 
7 | 


--------------------------------------------------------------------------------
/MetaLisp.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef __METALISP_H__
  2 | #define __METALISP_H__
  3 | 
  4 | #include <iostream>
  5 | 
  6 | struct number_tag {
  7 |     static const bool is_pair = false;
  8 |     static const bool is_null = false;
  9 |     static const bool is_number = true;
 10 |     static const bool is_boolean = false;
 11 |     static const bool is_symbol = false;
 12 | };
 13 | 
 14 | struct null_tag {
 15 |     static const bool is_pair = false;
 16 |     static const bool is_null = true;
 17 |     static const bool is_number = false;
 18 |     static const bool is_boolean = false;
 19 |     static const bool is_symbol = false;
 20 | };
 21 | 
 22 | struct pair_tag {
 23 |     static const bool is_pair = true;
 24 |     static const bool is_null = false;
 25 |     static const bool is_number = false;
 26 |     static const bool is_boolean = false;
 27 |     static const bool is_symbol = false;
 28 | };
 29 | 
 30 | struct boolean_tag {
 31 |     static const bool is_pair = false;
 32 |     static const bool is_null = false;
 33 |     static const bool is_number = false;
 34 |     static const bool is_boolean = true;
 35 |     static const bool is_symbol = false;
 36 | };
 37 | 
 38 | struct symbol_tag {
 39 |     static const bool is_pair = false;
 40 |     static const bool is_null = false;
 41 |     static const bool is_number = false;
 42 |     static const bool is_boolean = false;
 43 |     static const bool is_symbol = true;
 44 | };
 45 | 
 46 | namespace impl {
 47 |     template <int64_t x, int64_t y>
 48 |     struct gcd {
 49 |         static const int64_t value = gcd<y, x % y>::value;
 50 |     };
 51 | 
 52 |     template <int64_t x>
 53 |     struct gcd<x, 0> {
 54 |         static const int64_t value = x;
 55 |     };
 56 | 
 57 |     template <bool isNegN, bool isNegD, int64_t N, int64_t D>
 58 |     struct rat_gcd;
 59 | 
 60 |     template <int64_t N, int64_t D>
 61 |     struct rat_gcd<false, false, N, D> {
 62 |         static const int64_t value = gcd<N, D>::value;
 63 |     };
 64 | 
 65 |     template <int64_t N, int64_t D>
 66 |     struct rat_gcd<true, true, N, D> {
 67 |         static const int64_t value = -gcd<-N, -D>::value;
 68 |     };
 69 | 
 70 |     template <int64_t N, int64_t D>
 71 |     struct rat_gcd<true, false, N, D> {
 72 |         static const int64_t value = gcd<-N, D>::value;
 73 |     };
 74 | 
 75 |     template <int64_t N, int64_t D>
 76 |     struct rat_gcd<false, true, N, D> {
 77 |         static const int64_t value = -gcd<N, -D>::value;
 78 |     };
 79 | 
 80 |     template <bool isZero, int64_t N, int64_t D>
 81 |     struct rat_reduce {
 82 |         static const int64_t numer = 0;
 83 |         static const int64_t denom = 1;
 84 |     };
 85 | 
 86 |     template <int64_t N, int64_t D>
 87 |     struct rat_reduce<false, N, D> {
 88 |         static const int64_t numer = N / rat_gcd<(N < 0), (D < 0), N, D>::value;
 89 |         static const int64_t denom = D / rat_gcd<(N < 0), (D < 0), N, D>::value;
 90 |     };
 91 | } // namespace impl
 92 | 
 93 | template <int64_t N, int64_t D = 1>
 94 | struct number {
 95 |     using type = number<N, D>;
 96 |     using tag = number_tag;
 97 |     static const int64_t numer = impl::rat_reduce<(N == 0 || D == 0), N, D>::numer;
 98 |     static const int64_t denom = impl::rat_reduce<(N == 0 || D == 0), N, D>::denom;
 99 | };
100 | 
101 | // from https://github.com/irrequietus/typestring
102 | namespace impl {
103 |     template <char... C>
104 |     struct Symbol {
105 |         using type = Symbol<C...>;
106 |         using tag = symbol_tag;
107 |         static constexpr char const value[sizeof...(C) + 1] = {C..., '\0'};
108 |         
109 |     };
110 | 
111 |     template <int N, int M>
112 |     constexpr char tygrab(char const (&c)[M]) noexcept {
113 |         return c[N < M ? N : M - 1];
114 |     }
115 | 
116 |     template <char... X>
117 |     auto typoke(Symbol<X...>) -> Symbol<X...>;
118 | 
119 |     template <char... X, char... Y>
120 |     auto typoke(Symbol<X...>, Symbol<'\0'>, Symbol<Y>...) -> Symbol<X...>;
121 | 
122 |     template <char A, char... X, char... Y>
123 |     auto typoke(Symbol<X...>, Symbol<A>, Symbol<Y>...) -> decltype(typoke(Symbol<X..., A>(), Symbol<Y>()...));
124 | 
125 |     template <char... C>
126 |     auto typeek(Symbol<C...>) -> decltype(typoke(Symbol<C>()...));
127 | }
128 | 
129 | #define TYPESTRING16(n, x)                                                                                      \
130 |     impl::tygrab<0x##n##0>(x), impl::tygrab<0x##n##1>(x), impl::tygrab<0x##n##2>(x), impl::tygrab<0x##n##3>(x), \
131 |     impl::tygrab<0x##n##4>(x), impl::tygrab<0x##n##5>(x), impl::tygrab<0x##n##6>(x), impl::tygrab<0x##n##7>(x), \
132 |     impl::tygrab<0x##n##8>(x), impl::tygrab<0x##n##9>(x), impl::tygrab<0x##n##A>(x), impl::tygrab<0x##n##B>(x), \
133 |     impl::tygrab<0x##n##C>(x), impl::tygrab<0x##n##D>(x), impl::tygrab<0x##n##E>(x), impl::tygrab<0x##n##F>(x)
134 | 
135 | #define TYPESTRING32(n, x) TYPESTRING16(n##0, x), TYPESTRING16(n##1, x)
136 | 
137 | #define symbol(x) decltype(impl::typeek(impl::Symbol<TYPESTRING32(, x)>()))
138 | 
139 | template <bool flag>
140 | struct boolean {
141 |     using tag = boolean_tag;
142 |     using type = boolean<flag>;
143 |     static const bool value = flag;
144 | };
145 | 
146 | struct null {
147 |     using tag = null_tag;
148 |     using type = null;
149 | };
150 | 
151 | template <typename T, typename U>
152 | struct pair {
153 |     using tag = pair_tag;
154 |     using type = pair<T, U>;
155 |     using car_ = typename T::type;
156 |     using cdr_ = typename U::type;
157 | };
158 | 
159 | template <typename T>
160 | using is_null = boolean<T::tag::is_null>;
161 | 
162 | template <typename T>
163 | using is_pair = boolean<T::tag::is_pair>;
164 | 
165 | template <typename T>
166 | using is_number = boolean<T::tag::is_number>;
167 | 
168 | template <typename T>
169 | using is_boolean = boolean<T::tag::is_boolean>;
170 | 
171 | template <typename T>
172 | using is_symbol = boolean<T::tag::is_symbol>;
173 | 
174 | ///////////////////////////////////////////////////////////////
175 | template <typename... T>
176 | struct list;
177 | 
178 | template <typename T>
179 | struct list<T> : public pair<T, null> {};
180 | 
181 | template <typename T, typename... X>
182 | struct list<T, X...> : public pair<T, list<X...>> {};
183 | 
184 | template <int ... N>
185 | struct number_list;
186 | 
187 | template <int N>
188 | struct number_list<N> : public pair<number<N>, null> {};
189 | 
190 | template <int M, int... N>
191 | struct number_list<M, N...> : public pair<number<M>, number_list<N...>> {};
192 | 
193 | template <typename x>
194 | struct car {
195 |     using type = typename x::type::car_;
196 |     using tag = typename type::tag;
197 | };
198 | 
199 | template <typename x>
200 | struct cdr {
201 |     using type = typename x::type::cdr_;
202 |     using tag = typename type::tag;
203 | };
204 | 
205 | template <typename T, typename U>
206 | struct cons : public pair<T, U> {};
207 | 
208 | template <typename x>
209 | using cadr = car<cdr<x>>;
210 | 
211 | template <typename x>
212 | using cddr = cdr<cdr<x>>;
213 | 
214 | template <typename x>
215 | using caddr = car<cdr<cdr<x>>>;
216 | 
217 | template <typename x>
218 | using cadddr = car<cdr<cdr<cdr<x>>>>;
219 | 
220 | ///////////////////////////////////////////////////////////////
221 | template <typename Flag, typename True, typename False>
222 | struct if_else_impl : public True {};
223 | 
224 | template <typename True, typename False>
225 | struct if_else_impl<boolean<false>, True, False> : public False {};
226 | 
227 | template <typename Flag, typename True, typename False>
228 | struct if_else : public if_else_impl<typename Flag::type, True, False> {};
229 | 
230 | template <typename... x>
231 | struct cond;
232 | 
233 | template <typename Flag, typename S, typename... X>
234 | struct cond<Flag, S, X...> : public if_else<Flag, S, cond<X...>> {};
235 | 
236 | template <typename Else>
237 | struct cond<Else> : public Else {};
238 | 
239 | //////////////////////////////////////////////////////////////
240 | template <typename a, typename b>
241 | struct or_ : public boolean<(a::type::value || b::type::value)> {};
242 | 
243 | template <typename a, typename b>
244 | struct and_ : public boolean<(a::type::value && b::type::value)> {};
245 | 
246 | template <typename a>
247 | struct not_ : public boolean<(!a::type::value)> {};
248 | 
249 | /////////////////////////////////////////
250 | namespace impl {
251 |     template <int64_t n0, int64_t d0, int64_t n1, int64_t d1>
252 |     using add = number<n0 * d1 + n1 * d0, d0 * d1>;
253 | 
254 |     template <int64_t n0, int64_t d0, int64_t n1, int64_t d1>
255 |     using sub = number<n0 * d1 - n1 * d0, d0 * d1>;
256 | 
257 |     template <int64_t n0, int64_t d0, int64_t n1, int64_t d1>
258 |     using is_greater = boolean<(n0 * d1 > d0 * n1)>;
259 | 
260 |     template <int64_t n0, int64_t d0, int64_t n1, int64_t d1>
261 |     using is_less = boolean<(n0 * d1 < d0 * n1)>;
262 | }; // namespace impl
263 | 
264 | template <typename a, typename b>
265 | struct add : public impl::add<a::type::numer, a::type::denom, b::type::numer, b::type::denom> {};
266 | 
267 | template <typename a, typename b>
268 | struct sub : public impl::sub<a::type::numer, a::type::denom, b::type::numer, b::type::denom> {};
269 | 
270 | template <typename a, typename b>
271 | struct mul : public number<a::type::numer * b::type::numer, a::type::denom * b::type::denom> {};
272 | 
273 | template <typename a, typename b>
274 | struct div_ : public number<a::type::numer * b::type::denom, a::type::denom * b::type::numer> {};
275 | 
276 | template <typename a, typename b>
277 | struct is_greater : public impl::is_greater<a::type::numer, a::type::denom, b::type::numer, b::type::denom> {};
278 | 
279 | template <typename a, typename b>
280 | struct is_less : public impl::is_less<a::type::numer, a::type::denom, b::type::numer, b::type::denom> {};
281 | 
282 | template <typename a>
283 | struct abs_ : public if_else<is_greater<a, number<0>>, a, number<-a::type::numer, a::type::denom>> {};
284 | 
285 | template <typename a, typename b, typename tagA, typename tagB>
286 | struct is_equal_impl : public boolean<false> {};
287 | 
288 | template <typename a, typename b>
289 | struct is_equal_impl<a, b, number_tag, number_tag> : public boolean<(a::type::numer == b::type::numer && a::type::denom == b::type::denom)> {};
290 | 
291 | template <typename a, typename b>
292 | struct is_equal_impl<a, b, symbol_tag, symbol_tag> : public boolean<(a::type::value == b::type::value)> {};
293 | 
294 | template <typename a, typename b>
295 | struct is_equal : public is_equal_impl<a, b, typename a::tag, typename b::tag> {};
296 | 
297 | template <typename a, typename b>
298 | struct not_equal : public not_<is_equal<a, b>> {};
299 | 
300 | /////////////////////////////////////////////////////////////////////
301 | template <typename T>
302 | struct display_impl {
303 |     static std::ostream &display(std::ostream &os, bool showBracket, number_tag) {
304 |         if (T::type::denom == 1) {
305 |             return os << T::type::numer;
306 |         } else {
307 |             return os << static_cast<double>(T::type::numer) / static_cast<double>(T::type::denom);
308 |         }
309 |     }
310 |     
311 |     static std::ostream &display(std::ostream &os, bool showBracket, symbol_tag) {
312 |         return os << T::type::value;
313 |     }
314 | 
315 |     static std::ostream &display(std::ostream &os, bool showBracket, boolean_tag) {
316 |         if (T::type::value) {
317 |             os << "#t";
318 |         } else {
319 |             os << "#f";
320 |         }
321 |         return os;
322 |     }
323 | 
324 |     static std::ostream &display(std::ostream &os, bool showBracket, null_tag) {
325 |         os << "()";
326 |         return os;
327 |     }
328 | 
329 |     static std::ostream &display(std::ostream &os, bool showBracket, pair_tag) {
330 |         if (showBracket) {
331 |             os << "(";
332 |         }
333 |         display_impl<car<T>>::display(os, true);
334 |         using cdrT = cdr<T>;
335 |         if (is_null<cdrT>::value) {
336 |             // nothing
337 |         } else if (is_pair<cdrT>::value) {
338 |             os << " ";
339 |             display_impl<cdr<T>>::display(os, false);
340 |         } else {
341 |             os << " . ";
342 |             display_impl<cdr<T>>::display(os, false);
343 |         }
344 |         if (showBracket) {
345 |             os << ")";
346 |         }
347 |         return os;
348 |     }
349 | 
350 |     static std::ostream &display(std::ostream &os, bool showBracket) {
351 |         return display(os, showBracket, typename T::tag());
352 |     }
353 | };
354 | 
355 | template <typename T>
356 | void display(std::ostream &os = std::cout) {
357 |     display_impl<T>::display(os, true) << std::endl;
358 | };
359 | 
360 | //////////////////////////////////////////////
361 | 
362 | template <typename items>
363 | struct length : public if_else<is_null<items>, number<0>, add<number<1>, length<cdr<items>>>> {};
364 | 
365 | template <typename items, typename n>
366 | struct list_ref : public if_else<is_equal<n, number<0>>, car<items>, list_ref<cdr<items>, sub<n, number<1>>>> {};
367 | 
368 | template <template <typename> typename op, typename seq>
369 | struct map : public if_else<is_null<seq>, null, cons<op<car<seq>>, map<op, cdr<seq>>>> {};
370 | 
371 | template <template <typename, typename> typename op, typename seq0, typename seq1>
372 | struct map2 {
373 |     using type = typename if_else<or_<is_null<seq0>, is_null<seq1>>,
374 |                                   null,
375 |                                   cons<op<car<seq0>, car<seq1>>, map2<op, cdr<seq0>, cdr<seq1>>>>::type;
376 |     using tag = typename type::tag;
377 | };
378 | 
379 | template <template <typename, typename> typename op, typename initial, typename seq>
380 | struct accumulate : public if_else<is_null<seq>, initial, op<car<seq>, accumulate<op, initial, cdr<seq>>>> {};
381 | 
382 | template <typename a, typename b>
383 | struct append : public if_else<is_null<a>, b, cons<car<a>, append<cdr<a>, b>>> {};
384 | 
385 | template <typename items>
386 | struct reverse {
387 |     template <typename items2, typename result>
388 |     struct iter : public if_else<is_null<items2>, result, iter<cdr<items2>, cons<car<items2>, result>>> {};
389 | 
390 |     using type = typename iter<items, null>::type;
391 |     using tag = typename type::tag;
392 | };
393 | 
394 | template <template <typename> typename op, typename seq>
395 | struct filter {
396 |     using type = typename cond<is_null<seq>, null, op<car<seq>>, cons<car<seq>, filter<op, cdr<seq>>>, filter<op, cdr<seq>>>::type;
397 |     using tag = typename type::tag;
398 | };
399 | 
400 | template <template <typename> typename op, typename seq>
401 | struct flatmap : public accumulate<append, null, map<op, seq>> {};
402 | 
403 | #endif
404 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## MetaLisp
 2 | 
 3 | 使用 C++ 模板元编程来模拟 Scheme 的 car、cdr、cons、lisp  等语法。需要 C++ 17 支持。
 4 | 
 5 | 我是在 Mac 系统，使用 clang 编译器测试。它默认的模板嵌套是 1024 层。也可以用编译选项
 6 | 
 7 | ```
 8 | -ftemplate-depth=N
 9 | ```
10 | 
11 | 修改嵌套层数。
12 | 
13 | ### 模拟 Scheme 函数
14 | 
15 | [MetaLisp.hpp](./MetaLisp.hpp) 用于模拟 Scheme 的一些常用函数。比如下面 Scheme 函数
16 | 
17 | ```Scheme
18 | (define (append a b)
19 |   (if (null? a)
20 |       b
21 |       (cons (car a) (append (cdr a) b))))
22 | 
23 | (define (reverse items)
24 |   (define (iter items result)
25 |     (if (null? items)
26 |         result
27 |         (iter (cdr items) (cons (car items) result))))
28 |   (iter items null))
29 | ```
30 | 
31 | C++ 相应写成
32 | 
33 | ```C++
34 | template <typename a, typename b>
35 | struct append : public if_else<is_null<a>, b, cons<car<a>, append<cdr<a>, b>>> {};
36 | 
37 | template <typename items>
38 | struct reverse {
39 |     template <typename items2, typename result>
40 |     struct iter : public if_else<is_null<items2>, result, iter<cdr<items2>, cons<car<items2>, result>>> {};
41 | 
42 |     using type = typename iter<items, null>::type;
43 |     using tag = typename type::tag;
44 | };
45 | ```
46 | 
47 | C++ 每个模板类，相当于 Scheme 的一个函数。结果存放在模板类的 type 中。
48 | 
49 | 
50 | 
51 | ### 元编程例子
52 | 
53 | * [求解八皇后问题](./examples/queen.hpp)
54 | * [计算阶乘](./examples/factorial.hpp)
55 | * [平方根](./examples/sqrt.hpp)
56 | * [huffman 编码](./examples/huffman.hpp)
57 | 
58 | 
59 | 


--------------------------------------------------------------------------------
/examples/MetaLisp.xcodeproj/project.pbxproj:
--------------------------------------------------------------------------------
  1 | // !$*UTF8*$!
  2 | {
  3 | 	archiveVersion = 1;
  4 | 	classes = {
  5 | 	};
  6 | 	objectVersion = 50;
  7 | 	objects = {
  8 | 
  9 | /* Begin PBXBuildFile section */
 10 | 		2EDB5323244C87FB00DFB1C1 /* main.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2EDB5322244C87FB00DFB1C1 /* main.cpp */; };
 11 | /* End PBXBuildFile section */
 12 | 
 13 | /* Begin PBXCopyFilesBuildPhase section */
 14 | 		2E874E24244ACBFA00AE113B /* CopyFiles */ = {
 15 | 			isa = PBXCopyFilesBuildPhase;
 16 | 			buildActionMask = 2147483647;
 17 | 			dstPath = /usr/share/man/man1/;
 18 | 			dstSubfolderSpec = 0;
 19 | 			files = (
 20 | 			);
 21 | 			runOnlyForDeploymentPostprocessing = 1;
 22 | 		};
 23 | /* End PBXCopyFilesBuildPhase section */
 24 | 
 25 | /* Begin PBXFileReference section */
 26 | 		2E874E26244ACBFA00AE113B /* MetaLisp */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = MetaLisp; sourceTree = BUILT_PRODUCTS_DIR; };
 27 | 		2EB196A2244F36FA0061CF2C /* huffman.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = huffman.hpp; sourceTree = "<group>"; };
 28 | 		2EDB531D244C87FB00DFB1C1 /* queen.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = queen.hpp; sourceTree = "<group>"; };
 29 | 		2EDB5321244C87FB00DFB1C1 /* factorial.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = factorial.hpp; sourceTree = "<group>"; };
 30 | 		2EDB5322244C87FB00DFB1C1 /* main.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = main.cpp; sourceTree = "<group>"; };
 31 | 		2EDB5324244C881600DFB1C1 /* MetaLisp.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = MetaLisp.hpp; path = ../MetaLisp.hpp; sourceTree = "<group>"; };
 32 | 		2EDB5325244C8EAD00DFB1C1 /* sqrt.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = sqrt.hpp; sourceTree = "<group>"; };
 33 | /* End PBXFileReference section */
 34 | 
 35 | /* Begin PBXFrameworksBuildPhase section */
 36 | 		2E874E23244ACBFA00AE113B /* Frameworks */ = {
 37 | 			isa = PBXFrameworksBuildPhase;
 38 | 			buildActionMask = 2147483647;
 39 | 			files = (
 40 | 			);
 41 | 			runOnlyForDeploymentPostprocessing = 0;
 42 | 		};
 43 | /* End PBXFrameworksBuildPhase section */
 44 | 
 45 | /* Begin PBXGroup section */
 46 | 		2E874E1D244ACBFA00AE113B = {
 47 | 			isa = PBXGroup;
 48 | 			children = (
 49 | 				2EDB5324244C881600DFB1C1 /* MetaLisp.hpp */,
 50 | 				2EDB531C244C87FB00DFB1C1 /* examples */,
 51 | 				2E874E27244ACBFA00AE113B /* Products */,
 52 | 			);
 53 | 			sourceTree = "<group>";
 54 | 		};
 55 | 		2E874E27244ACBFA00AE113B /* Products */ = {
 56 | 			isa = PBXGroup;
 57 | 			children = (
 58 | 				2E874E26244ACBFA00AE113B /* MetaLisp */,
 59 | 			);
 60 | 			name = Products;
 61 | 			sourceTree = "<group>";
 62 | 		};
 63 | 		2EDB531C244C87FB00DFB1C1 /* examples */ = {
 64 | 			isa = PBXGroup;
 65 | 			children = (
 66 | 				2EB196A2244F36FA0061CF2C /* huffman.hpp */,
 67 | 				2EDB5325244C8EAD00DFB1C1 /* sqrt.hpp */,
 68 | 				2EDB531D244C87FB00DFB1C1 /* queen.hpp */,
 69 | 				2EDB5321244C87FB00DFB1C1 /* factorial.hpp */,
 70 | 				2EDB5322244C87FB00DFB1C1 /* main.cpp */,
 71 | 			);
 72 | 			name = examples;
 73 | 			sourceTree = "<group>";
 74 | 		};
 75 | /* End PBXGroup section */
 76 | 
 77 | /* Begin PBXNativeTarget section */
 78 | 		2E874E25244ACBFA00AE113B /* MetaLisp */ = {
 79 | 			isa = PBXNativeTarget;
 80 | 			buildConfigurationList = 2E874E2D244ACBFA00AE113B /* Build configuration list for PBXNativeTarget "MetaLisp" */;
 81 | 			buildPhases = (
 82 | 				2E874E22244ACBFA00AE113B /* Sources */,
 83 | 				2E874E23244ACBFA00AE113B /* Frameworks */,
 84 | 				2E874E24244ACBFA00AE113B /* CopyFiles */,
 85 | 			);
 86 | 			buildRules = (
 87 | 			);
 88 | 			dependencies = (
 89 | 			);
 90 | 			name = MetaLisp;
 91 | 			productName = MetaQueen;
 92 | 			productReference = 2E874E26244ACBFA00AE113B /* MetaLisp */;
 93 | 			productType = "com.apple.product-type.tool";
 94 | 		};
 95 | /* End PBXNativeTarget section */
 96 | 
 97 | /* Begin PBXProject section */
 98 | 		2E874E1E244ACBFA00AE113B /* Project object */ = {
 99 | 			isa = PBXProject;
100 | 			attributes = {
101 | 				LastUpgradeCheck = 1140;
102 | 				ORGANIZATIONNAME = HJC;
103 | 				TargetAttributes = {
104 | 					2E874E25244ACBFA00AE113B = {
105 | 						CreatedOnToolsVersion = 11.4.1;
106 | 					};
107 | 				};
108 | 			};
109 | 			buildConfigurationList = 2E874E21244ACBFA00AE113B /* Build configuration list for PBXProject "MetaLisp" */;
110 | 			compatibilityVersion = "Xcode 9.3";
111 | 			developmentRegion = en;
112 | 			hasScannedForEncodings = 0;
113 | 			knownRegions = (
114 | 				en,
115 | 				Base,
116 | 			);
117 | 			mainGroup = 2E874E1D244ACBFA00AE113B;
118 | 			productRefGroup = 2E874E27244ACBFA00AE113B /* Products */;
119 | 			projectDirPath = "";
120 | 			projectRoot = "";
121 | 			targets = (
122 | 				2E874E25244ACBFA00AE113B /* MetaLisp */,
123 | 			);
124 | 		};
125 | /* End PBXProject section */
126 | 
127 | /* Begin PBXSourcesBuildPhase section */
128 | 		2E874E22244ACBFA00AE113B /* Sources */ = {
129 | 			isa = PBXSourcesBuildPhase;
130 | 			buildActionMask = 2147483647;
131 | 			files = (
132 | 				2EDB5323244C87FB00DFB1C1 /* main.cpp in Sources */,
133 | 			);
134 | 			runOnlyForDeploymentPostprocessing = 0;
135 | 		};
136 | /* End PBXSourcesBuildPhase section */
137 | 
138 | /* Begin XCBuildConfiguration section */
139 | 		2E874E2B244ACBFA00AE113B /* Debug */ = {
140 | 			isa = XCBuildConfiguration;
141 | 			buildSettings = {
142 | 				ALWAYS_SEARCH_USER_PATHS = NO;
143 | 				CLANG_ANALYZER_NONNULL = YES;
144 | 				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
145 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
146 | 				CLANG_CXX_LIBRARY = "libc++";
147 | 				CLANG_ENABLE_MODULES = YES;
148 | 				CLANG_ENABLE_OBJC_ARC = YES;
149 | 				CLANG_ENABLE_OBJC_WEAK = YES;
150 | 				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
151 | 				CLANG_WARN_BOOL_CONVERSION = YES;
152 | 				CLANG_WARN_COMMA = YES;
153 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
154 | 				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
155 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
156 | 				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
157 | 				CLANG_WARN_EMPTY_BODY = YES;
158 | 				CLANG_WARN_ENUM_CONVERSION = YES;
159 | 				CLANG_WARN_INFINITE_RECURSION = YES;
160 | 				CLANG_WARN_INT_CONVERSION = YES;
161 | 				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
162 | 				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
163 | 				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
164 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
165 | 				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
166 | 				CLANG_WARN_STRICT_PROTOTYPES = YES;
167 | 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
168 | 				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
169 | 				CLANG_WARN_UNREACHABLE_CODE = YES;
170 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
171 | 				COPY_PHASE_STRIP = NO;
172 | 				DEBUG_INFORMATION_FORMAT = dwarf;
173 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
174 | 				ENABLE_TESTABILITY = YES;
175 | 				GCC_C_LANGUAGE_STANDARD = gnu11;
176 | 				GCC_DYNAMIC_NO_PIC = NO;
177 | 				GCC_NO_COMMON_BLOCKS = YES;
178 | 				GCC_OPTIMIZATION_LEVEL = 0;
179 | 				GCC_PREPROCESSOR_DEFINITIONS = (
180 | 					"DEBUG=1",
181 | 					"$(inherited)",
182 | 				);
183 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
184 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
185 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
186 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
187 | 				GCC_WARN_UNUSED_FUNCTION = YES;
188 | 				GCC_WARN_UNUSED_VARIABLE = YES;
189 | 				MACOSX_DEPLOYMENT_TARGET = 10.15;
190 | 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
191 | 				MTL_FAST_MATH = YES;
192 | 				ONLY_ACTIVE_ARCH = YES;
193 | 				SDKROOT = macosx;
194 | 			};
195 | 			name = Debug;
196 | 		};
197 | 		2E874E2C244ACBFA00AE113B /* Release */ = {
198 | 			isa = XCBuildConfiguration;
199 | 			buildSettings = {
200 | 				ALWAYS_SEARCH_USER_PATHS = NO;
201 | 				CLANG_ANALYZER_NONNULL = YES;
202 | 				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
203 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
204 | 				CLANG_CXX_LIBRARY = "libc++";
205 | 				CLANG_ENABLE_MODULES = YES;
206 | 				CLANG_ENABLE_OBJC_ARC = YES;
207 | 				CLANG_ENABLE_OBJC_WEAK = YES;
208 | 				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
209 | 				CLANG_WARN_BOOL_CONVERSION = YES;
210 | 				CLANG_WARN_COMMA = YES;
211 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
212 | 				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
213 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
214 | 				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
215 | 				CLANG_WARN_EMPTY_BODY = YES;
216 | 				CLANG_WARN_ENUM_CONVERSION = YES;
217 | 				CLANG_WARN_INFINITE_RECURSION = YES;
218 | 				CLANG_WARN_INT_CONVERSION = YES;
219 | 				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
220 | 				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
221 | 				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
222 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
223 | 				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
224 | 				CLANG_WARN_STRICT_PROTOTYPES = YES;
225 | 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
226 | 				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
227 | 				CLANG_WARN_UNREACHABLE_CODE = YES;
228 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
229 | 				COPY_PHASE_STRIP = NO;
230 | 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
231 | 				ENABLE_NS_ASSERTIONS = NO;
232 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
233 | 				GCC_C_LANGUAGE_STANDARD = gnu11;
234 | 				GCC_NO_COMMON_BLOCKS = YES;
235 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
236 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
237 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
238 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
239 | 				GCC_WARN_UNUSED_FUNCTION = YES;
240 | 				GCC_WARN_UNUSED_VARIABLE = YES;
241 | 				MACOSX_DEPLOYMENT_TARGET = 10.15;
242 | 				MTL_ENABLE_DEBUG_INFO = NO;
243 | 				MTL_FAST_MATH = YES;
244 | 				SDKROOT = macosx;
245 | 			};
246 | 			name = Release;
247 | 		};
248 | 		2E874E2E244ACBFA00AE113B /* Debug */ = {
249 | 			isa = XCBuildConfiguration;
250 | 			buildSettings = {
251 | 				CLANG_CXX_LANGUAGE_STANDARD = "c++17";
252 | 				CODE_SIGN_STYLE = Automatic;
253 | 				PRODUCT_NAME = "$(TARGET_NAME)";
254 | 			};
255 | 			name = Debug;
256 | 		};
257 | 		2E874E2F244ACBFA00AE113B /* Release */ = {
258 | 			isa = XCBuildConfiguration;
259 | 			buildSettings = {
260 | 				CLANG_CXX_LANGUAGE_STANDARD = "c++17";
261 | 				CODE_SIGN_STYLE = Automatic;
262 | 				PRODUCT_NAME = "$(TARGET_NAME)";
263 | 			};
264 | 			name = Release;
265 | 		};
266 | /* End XCBuildConfiguration section */
267 | 
268 | /* Begin XCConfigurationList section */
269 | 		2E874E21244ACBFA00AE113B /* Build configuration list for PBXProject "MetaLisp" */ = {
270 | 			isa = XCConfigurationList;
271 | 			buildConfigurations = (
272 | 				2E874E2B244ACBFA00AE113B /* Debug */,
273 | 				2E874E2C244ACBFA00AE113B /* Release */,
274 | 			);
275 | 			defaultConfigurationIsVisible = 0;
276 | 			defaultConfigurationName = Release;
277 | 		};
278 | 		2E874E2D244ACBFA00AE113B /* Build configuration list for PBXNativeTarget "MetaLisp" */ = {
279 | 			isa = XCConfigurationList;
280 | 			buildConfigurations = (
281 | 				2E874E2E244ACBFA00AE113B /* Debug */,
282 | 				2E874E2F244ACBFA00AE113B /* Release */,
283 | 			);
284 | 			defaultConfigurationIsVisible = 0;
285 | 			defaultConfigurationName = Release;
286 | 		};
287 | /* End XCConfigurationList section */
288 | 	};
289 | 	rootObject = 2E874E1E244ACBFA00AE113B /* Project object */;
290 | }
291 | 


--------------------------------------------------------------------------------
/examples/factorial.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __FACTORIAL_HPP__
 2 | #define __FACTORIAL_HPP__
 3 | 
 4 | #include "MetaLisp.hpp"
 5 | 
 6 | // 计算阶乘
 7 | // 相应的 Scheme 代码见 https://github.com/hjcapple/reading-sicp/blob/master/chapter_1/factorial.scm
 8 | 
 9 | template <typename n>
10 | struct factorial {
11 |     using one = number<1>;
12 |     using type = typename if_else<is_equal<n, one>, one, mul<n, factorial<sub<n, one>>>>::type;
13 |     using tag = typename type::tag;
14 | };
15 | 
16 | template <typename n>
17 | struct factorial_2 {
18 |     using one = number<1>;
19 |     template <typename product, typename counter, typename max_count>
20 |     struct fact_iter {
21 |         using type = typename if_else<is_greater<counter, max_count>,
22 |                                       product,
23 |                                       fact_iter<mul<counter, product>, add<counter, one>, max_count>>::type;
24 |         using tag = typename type::tag;
25 |     };
26 |     using type = typename fact_iter<one, one, n>::type;
27 |     using tag = typename type::tag;
28 | };
29 | 
30 | static inline void test_factorial() {
31 |     printf("factorial: \n");
32 |     display<factorial<number<10>>>();   // 3628800
33 |     display<factorial_2<number<10>>>(); // 3628800
34 |     printf("\n");
35 | }
36 | 
37 | #endif
38 | 


--------------------------------------------------------------------------------
/examples/huffman.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef __HUFFMAN_HPP__
  2 | #define __HUFFMAN_HPP__
  3 | 
  4 | #include "MetaLisp.hpp"
  5 | 
  6 | // huffman 编码
  7 | // 相应的 Scheme 代码见 https://github.com/hjcapple/reading-sicp/blob/master/chapter_2/exercise_2_69.scm
  8 | 
  9 | template <typename symbol_, typename weight>
 10 | struct make_leaf : public list<symbol("leaf"), symbol_, weight> {};
 11 | 
 12 | template <typename object>
 13 | struct is_leaf : public is_equal<car<object>, symbol("leaf")> {};
 14 | 
 15 | template <typename x>
 16 | struct symbol_leaf : public cadr<x> {};
 17 | 
 18 | template <typename x>
 19 | struct weight_leaf : public caddr<x> {};
 20 | 
 21 | template <typename tree>
 22 | struct symbol_ : public if_else<is_leaf<tree>, list<symbol_leaf<tree>>, caddr<tree>> {};
 23 | 
 24 | template <typename tree>
 25 | struct weight : public if_else<is_leaf<tree>, weight_leaf<tree>, cadddr<tree>> {};
 26 | 
 27 | template <typename left, typename right>
 28 | struct make_code_tree {
 29 |     using type =
 30 |         typename list<left, right, append<symbol_<left>, symbol_<right>>, add<weight<left>, weight<right>>>::type;
 31 |     using tag = typename type::tag;
 32 | };
 33 | 
 34 | template <typename tree>
 35 | struct left_branch : public car<tree> {};
 36 | 
 37 | template <typename tree>
 38 | struct right_branch : public cadr<tree> {};
 39 | 
 40 | template <typename bit, typename branch>
 41 | struct choose_branch {
 42 |     using type = typename cond<is_equal<bit, number<0>>,
 43 |                                left_branch<branch>,
 44 |                                is_equal<bit, number<1>>,
 45 |                                right_branch<branch>,
 46 |                                null>::type;
 47 |     using tag = typename type::tag;
 48 | };
 49 | 
 50 | template <typename bits, typename tree>
 51 | struct decode {
 52 |     template <typename bits_2, typename current_branch>
 53 |     struct decode_1 {
 54 |         struct Else {
 55 |             using next_branch = choose_branch<car<bits_2>, current_branch>;
 56 |             using type = typename if_else<is_leaf<next_branch>,
 57 |                                           cons<symbol_leaf<next_branch>, decode_1<cdr<bits_2>, tree>>,
 58 |                                           decode_1<cdr<bits_2>, next_branch>>::type;
 59 |         };
 60 |         using type = typename if_else<is_null<bits_2>, null, Else>::type;
 61 |     };
 62 |     using type = typename decode_1<bits, tree>::type;
 63 |     using tag = typename type::tag;
 64 | };
 65 | 
 66 | template <typename sym, typename tree>
 67 | struct encode_symbol {
 68 |     struct Else {
 69 |         struct Else2 {
 70 |             using right_result = encode_symbol<sym, right_branch<tree>>;
 71 |             using type = typename if_else<right_result, cons<number<1>, right_result>, boolean<false>>::type;
 72 |         };
 73 |         using left_right = encode_symbol<sym, left_branch<tree>>;
 74 |         using type = typename if_else<left_right, cons<number<0>, left_right>, Else2>::type;
 75 |     };
 76 |     using type =
 77 |         typename if_else<is_leaf<tree>, if_else<is_equal<sym, symbol_leaf<tree>>, null, boolean<false>>, Else>::type;
 78 |     using tag = typename type::tag;
 79 | };
 80 | 
 81 | template <typename message, typename tree>
 82 | struct encode {
 83 |     using type = typename if_else<is_null<message>,
 84 |                                   null,
 85 |                                   append<encode_symbol<car<message>, tree>, encode<cdr<message>, tree>>>::type;
 86 |     using tag = typename type::tag;
 87 | };
 88 | 
 89 | template <typename x, typename set>
 90 | struct adjoin_set {
 91 |     using type = typename cond<is_null<set>,
 92 |                                list<x>,
 93 |                                is_less<weight<x>, weight<car<set>>>,
 94 |                                cons<x, set>,
 95 |                                cons<car<set>, adjoin_set<x, cdr<set>>>>::type;
 96 |     using tag = typename type::tag;
 97 | };
 98 | 
 99 | template <typename pairs>
100 | struct make_leaf_set {
101 |     struct Else {
102 |         using pair_ = car<pairs>;
103 |         using type = typename adjoin_set<make_leaf<car<pair_>, cadr<pair_>>, make_leaf_set<cdr<pairs>>>::type;
104 |     };
105 |     using type = typename if_else<is_null<pairs>, null, Else>::type;
106 |     using tag = typename type::tag;
107 | };
108 | 
109 | template <typename set>
110 | struct successive_merge {
111 |     struct Else {
112 |         using left = car<set>;
113 |         using right = cadr<set>;
114 |         using remained = cddr<set>;
115 |         using type = typename successive_merge<adjoin_set<make_code_tree<left, right>, remained>>::type;
116 |     };
117 |     using type = typename if_else<is_equal<length<set>, number<1>>, car<set>, Else>::type;
118 |     using tag = typename type::tag;
119 | };
120 | 
121 | template <typename pairs>
122 | struct generate_huffman_tree : public successive_merge<typename make_leaf_set<pairs>::type> {};
123 | 
124 | //////////////////////////////////////////////
125 | 
126 | static inline void test_huffman() {
127 |     printf("huffman: \n");
128 |     using huffman_pair = typename list<list<symbol("A"), number<4>>,
129 |                                        list<symbol("B"), number<2>>,
130 |                                        list<symbol("C"), number<1>>,
131 |                                        list<symbol("D"), number<1>>>::type;
132 | 
133 |     using huffman_tree = generate_huffman_tree<huffman_pair>;
134 |     using symbols = list<symbol("A"), symbol("D"), symbol("A"), symbol("B"), symbol("B"), symbol("C"), symbol("A")>;
135 |     using message = encode<symbols, huffman_tree>;
136 | 
137 |     display<huffman_tree>(); // ((leaf A 4) ((leaf B 2) ((leaf D 1) (leaf C 1) (D C) 2) (B D C) 4) (A B D C) 8)
138 |     display<symbols>();      // (A D A B B C A)
139 |     display<message>();      // (0 1 1 0 0 1 0 1 0 1 1 1 0)
140 |     display<decode<message, huffman_tree>>(); // (A D A B B C A)
141 |     printf("\n");
142 | }
143 | 
144 | #endif
145 | 


--------------------------------------------------------------------------------
/examples/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "factorial.hpp"
 2 | #include "queen.hpp"
 3 | #include "sqrt.hpp"
 4 | #include "huffman.hpp"
 5 | 
 6 | // 测试符号
 7 | static void test_symbol() {
 8 |     printf("symbol: \n");
 9 |     using lst = list<list<symbol("Hello"), symbol("World")>, list<number<1>, number<2>>>;
10 |     display<lst>();
11 |     printf("\n");
12 | }
13 | 
14 | int main(int argc, char **argv) {
15 |     test_queen();
16 |     test_symbol();
17 |     test_factorial();
18 |     test_sqrt();
19 |     test_huffman();
20 |     return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/examples/queen.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __QUEEN_HPP__
 2 | #define __QUEEN_HPP__
 3 | 
 4 | #include "MetaLisp.hpp"
 5 | 
 6 | // 求解八皇后问题
 7 | // 相应的 Scheme 代码见 https://github.com/hjcapple/reading-sicp/blob/master/chapter_2/exercise_2_42.scm
 8 | 
 9 | template <typename low, typename high>
10 | struct enumerate_interval {
11 |     using type =
12 |         typename if_else<is_greater<low, high>, null, cons<low, enumerate_interval<add<low, number<1>>, high>>>::type;
13 |     using tag = typename type::tag;
14 | };
15 | 
16 | using empty_board = null;
17 | 
18 | template <typename k, typename positions>
19 | struct is_safe {
20 |     template <typename v0, typename v1>
21 |     using is_same_row = is_equal<car<v0>, car<v1>>;
22 | 
23 |     template <typename v0, typename v1>
24 |     struct is_same_diag {
25 |         using tmp0 = typename abs_<sub<car<v0>, car<v1>>>::type;
26 |         using tmp1 = typename abs_<sub<cdr<v0>, cdr<v1>>>::type;
27 |         using type = typename is_equal<tmp0, tmp1>::type;
28 |     };
29 | 
30 |     using pair_list = typename map2<cons, positions, enumerate_interval<number<1>, k>>::type;
31 |     using val = typename car<pair_list>::type;
32 | 
33 |     template <typename x>
34 |     struct filter_op : public or_<is_same_row<x, val>, is_same_diag<x, val>> {};
35 | 
36 |     using type = typename is_equal<length<filter<filter_op, cdr<pair_list>>>, number<0>>::type;
37 |     using tag = typename type::tag;
38 | };
39 | 
40 | template <typename new_row, typename k, typename rest_of_queens>
41 | using adjoin_position = cons<new_row, rest_of_queens>;
42 | 
43 | template <typename board_size>
44 | struct queen {
45 |     template <typename k>
46 |     struct queen_cols {
47 |         template <typename positions>
48 |         using filter_lambda = is_safe<k, positions>;
49 | 
50 |         template <typename rest_of_queens>
51 |         struct flatmap_lambda {
52 |             template <typename new_row>
53 |             using map_lambda = adjoin_position<new_row, k, rest_of_queens>;
54 |             using type = typename map<map_lambda, enumerate_interval<number<1>, board_size>>::type;
55 |         };
56 | 
57 |         using type =
58 |             typename if_else<is_equal<k, number<0>>,
59 |                              list<empty_board>,
60 |                              filter<filter_lambda, flatmap<flatmap_lambda, queen_cols<sub<k, number<1>>>>>>::type;
61 |         using tag = typename type::tag;
62 |     };
63 |     using type = typename queen_cols<board_size>::type;
64 |     using tag = typename type::tag;
65 | };
66 | 
67 | static inline void test_queen() {
68 |     printf("queen: \n");
69 |     /*
70 |         ((4 2 5 3 1)
71 |         (3 5 2 4 1)
72 |         (5 3 1 4 2)
73 |         (4 1 3 5 2)
74 |         (5 2 4 1 3)
75 |         (1 4 2 5 3)
76 |         (2 5 3 1 4)
77 |         (1 3 5 2 4)
78 |         (3 1 4 2 5)
79 |         (2 4 1 3 5)) */
80 |     display<queen<number<5>>>();
81 |     printf("\n");
82 | }
83 | 
84 | #endif
85 | 


--------------------------------------------------------------------------------
/examples/sqrt.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __SQRT_HPP__
 2 | #define __SQRT_HPP__
 3 | 
 4 | #include "MetaLisp.hpp"
 5 | 
 6 | // 平方根
 7 | // 相应的 Scheme 代码见 https://github.com/hjcapple/reading-sicp/blob/master/chapter_1/newton_sqrt.scm
 8 | template <typename x, typename y>
 9 | struct average : public div_<add<x, y>, number<2>> {};
10 | 
11 | template <typename x>
12 | struct square : public mul<x, x> {};
13 | 
14 | template <typename guess, typename x>
15 | struct is_good_enough {
16 |     using type = typename is_less<abs_<sub<square<guess>, x>>, number<1, 1000>>::type;
17 |     using tag = typename type::tag;
18 | };
19 | 
20 | template <typename guess, typename x>
21 | struct improve : public average<guess, div_<x, guess>> {};
22 | 
23 | template <typename guess, typename x>
24 | struct sqrt_iter {
25 |     using type = typename if_else<is_good_enough<guess, x>, guess, sqrt_iter<improve<guess, x>, x>>::type;
26 |     using tag = typename type::tag;
27 | };
28 | 
29 | template <typename x>
30 | struct sqrt : public sqrt_iter<number<1>, x> {};
31 | 
32 | static void test_sqrt() {
33 |     printf("sqrt: \n");
34 |     display<sqrt<number<1>>>(); // 1
35 |     display<sqrt<number<2>>>(); // 1.41422
36 |     display<sqrt<number<3>>>(); // 1.73214
37 |     display<sqrt<number<4>>>(); // 2
38 |     display<sqrt<number<5>>>(); // 2.23607
39 |     display<sqrt<number<6>>>(); // 2.44949
40 |     printf("\n");
41 | }
42 | 
43 | #endif
44 | 


--------------------------------------------------------------------------------