OSDN > Developer > nirvana > Chamber > experiments > 提交

experiments
Fork

(Original repository, No fork origin)

提交

修订版	b28b114202f3ac0f4b35e2df52e8189ff0159491 (tree)
时间	2017-03-23 13:00:57
作者	Yamashta Daisuke <yamasdais@gmai...>
Commiter	Yamashta Daisuke

[refactor] conditional meta classes.
[add] t_type
[add] and, or

--- a/cxx/fmp.cc

+++ b/cxx/fmp.cc

		@@ -48,19 +48,26 @@ struct chary {
48	48	constexpr static T ary[size] = { V..., static_cast<T>(0) };
49	49	};
50	50
	51	+struct t_type : public std::true_type {
	52	+};
	53	+
51	54	struct nil_type : public std::false_type {
52	55	};
53	56
54		-#if 0
55		-template <typename T>
56		-std::false_type check_cons(...);
	57	+template <template <class> typename F, typename V>
	58	+class pred_elem {
	59	+ using apply = typename F<V>::apply;
	60	+};
57	61
58		-template <typename T>
59		-auto check_cons(T*) -> decltype(
60		- std::is_same<typename T::car_type, typename T::cdr_type>::value,
61		- std::true_type()
62		-);
63		-#endif
	62	+template <template <class> typename F, typename V>
	63	+constexpr static auto pred_elem_v = pred_elem<F, V>::apply::value;
	64	+
	65	+template <template <class> typename F>
	66	+class and_impl {
	67	+};
	68	+
	69	+class or_impl {
	70	+};
64	71
65	72	class is_cons_impl {
66	73	template <typename T>

		@@ -69,27 +76,41 @@ class is_cons_impl {
69	76	template <typename T>
70	77	static auto check(T*) -> decltype(
71	78	std::is_same<typename T::car_type, typename T::cdr_type>::value,
72		- std::true_type()
	79	+ t_type()
73	80	);
74	81	public:
75	82	template <typename T>
76		- using pred = decltype(check<T>(nullptr));
	83	+ using apply = decltype(check<T>(nullptr));
77	84	};
78	85
79	86	class is_atom_impl {
80	87	template <typename T>
81		- static std::true_type check(...);
	88	+ static t_type check(...);
82	89
83	90	template <typename T>
84	91	static auto check(T*)-> decltype(
85		- //std::is_same<typename T::car_type, typename T::cdr_type>::value,
86		- is_cons_impl::pred<T>::value,
	92	+ std::is_same<typename T::car_type, typename T::cdr_type>::value,
87	93	nil_type()
88	94	);
89	95
90	96	public:
91	97	template <typename T>
92		- using pred = decltype(check<T>(nullptr));
	98	+ using apply = decltype(check<T>(nullptr));
	99	+};
	100	+
	101	+struct is_t_impl {
	102	+ template <typename T>
	103	+ using apply = typename std::conditional<
	104	+ std::is_base_of<std::false_type, T>::value,
	105	+ nil_type, t_type>::type;
	106	+};
	107	+
	108	+
	109	+struct is_nil_impl {
	110	+ template <typename T>
	111	+ using apply = typename std::conditional<
	112	+ std::is_base_of<std::false_type, T>::value,
	113	+ t_type, nil_type>::type;
93	114	};
94	115
95	116	} // detail

		@@ -107,42 +128,30 @@ struct cons {
107	128	using cdr = detail::any<D>;
108	129	};
109	130
110		-
111		-template <typename T>
112		-struct is_t : public std::true_type { };
113		-
114		-template <>
115		-struct is_t<nil> : public nil { };
116		-
117	131	template <typename T>
118		-struct is_nil : public nil { };
119		-
120		-template <>
121		-struct is_nil<nil> : public std::true_type { };
	132	+struct is_t : public detail::is_t_impl::apply<T> {
	133	+};
122	134
123	135	template <typename T>
124		-struct is_cons : public detail::is_cons_impl::pred<T> {
	136	+struct is_nil : public detail::is_nil_impl::apply<T> {
125	137	};
126	138
127		-#if 0
128	139	template <typename T>
129		-struct is_atom : public std::true_type { };
	140	+struct is_cons : public detail::is_cons_impl::apply<T> {
	141	+};
130	142
131		-template <typename T0, typename T1>
132		-struct is_atom<cons<T0, T1>> : std::false_type { };
133		-#endif
134	143	template <typename T>
135		-struct is_atom : public detail::is_atom_impl::pred<T> {
	144	+struct is_atom : public detail::is_atom_impl::apply<T> {
136	145	};
137	146
138	147	template <typename T>
139	148	struct is_list : public nil { };
140	149
141	150	template <>
142		-struct is_list<nil> : public std::true_type { };
	151	+struct is_list<nil> : public detail::t_type { };
143	152
144	153	template <typename T0, typename T1>
145		-struct is_list<cons<T0, T1>> : public std::true_type { };
	154	+struct is_list<cons<T0, T1>> : public detail::t_type { };
146	155
147	156	namespace detail {
148	157

		@@ -162,6 +171,12 @@ struct list_elem<> {
162	171	}
163	172
164	173	template <typename T>
	174	+struct quote {
	175	+ using type = quote<T>;
	176	+ using apply = T;
	177	+};
	178	+
	179	+template <typename T>
165	180	struct car {
166	181	using apply = typename T::car_type;
167	182	};

		@@ -185,7 +200,7 @@ template <typename, typename>
185	200	struct eq : public nil { };
186	201
187	202	template <typename T>
188		-struct eq<T, T> : public std::true_type { };
	203	+struct eq<T, T> : public detail::t_type { };
189	204
190	205	template <typename ...T>
191	206	struct list {

		@@ -273,8 +288,7 @@ void test_atom() {
273	288	static_assert(is_t<is_atom<int>>::value, "is_atom<int> == t");
274	289	static_assert(is_t<is_atom<nil>>::value, "is_atom<nil> == t");
275	290	static_assert(!is_atom<cons<int>>::value, "is_atom<cons<int>> == nil");
276		-
277		- is_atom<cons<int>>::type foo;
	291	+ static_assert(is_nil<is_atom<cons<int>>>::value, "foo == nil");
278	292	}
279	293
280	294	void test0() {