1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
// PR c++/66067
// { dg-do compile { target c++11 } }
namespace std
{
typedef int size_t;
template < typename _Tp, _Tp > struct integral_constant
{
static constexpr _Tp value = 0;
typedef integral_constant type;
};
typedef integral_constant < int, 0 > true_type;
typedef integral_constant < int, 0 > false_type;
template < typename _Tp > struct enable_if
{
typedef _Tp type;
};
}
namespace meta
{
inline namespace v1
{
template < template < typename ... >class, typename ... >struct defer;
template < typename T > T * _nullptr_v ( );
template < int N > using size_t = std::integral_constant < int, N >;
template < int B > using bool_ = std::integral_constant < int, B >;
template < typename T > using dec =
std::integral_constant < decltype ( T::value ), 0 >;
template < typename T > using eval = typename T::type;
template < typename F, typename ... Args > using apply =
typename F::template apply < Args ... >;
namespace detail
{
template < typename > struct has_type_;
}
template < typename T > using has_type = eval < detail::has_type_ < T >>;
template < typename T > struct id
{
using type = T;
};
template < template < typename ... >class > struct quote;
template < typename > struct Trans_NS_extension_apply_list;
template < typename, typename List > using apply_list =
eval < Trans_NS_extension_apply_list < List >>;
namespace detail
{
template < typename ... >struct _if_;
template < typename If, typename Then > struct _if_ <If,
Then >:std::enable_if < Then >
{
};
}
template < typename ... Args > using if_ =
eval < detail::_if_ < Args ... >>;
template < int If, typename ... Args > using if_c =
eval < detail::_if_ < bool_ < If >, Args ... >>;
namespace detail
{
template < typename ... >struct _and_:std::true_type
{
};
template < typename ... >struct _or_:std::false_type
{
};
}
template < int >using not_c = bool_ < 0 >;
template < typename Bool > using not_ = not_c < Bool::value >;
template < typename ... >using and_ = eval < detail::_and_ <>>;
template < typename > using or_ = eval < detail::_or_ <>>;
namespace lazy
{
template < typename ... Bools > using and_ = defer < and_, Bools ... >;
}
template < typename ... Ts > struct list
{
static constexpr std::size_t size ( )
{
return sizeof ... ( Ts );
}
};
template < typename List > using size = size_t < List::size ( ) >;
namespace detail
{
template < typename > struct concat_;
}
template < typename ... Lists > using concat =
eval < detail::concat_ < Lists ... >>;
template < typename ListOfLists > using join =
apply_list < quote < concat >, ListOfLists >;
namespace detail
{
template < int >struct repeat_n_c_
{
using type = list <>;
};
}
template < typename > using repeat_n = eval < detail::repeat_n_c_ < 0 >>;
template < std::size_t N > using repeat_n_c =
eval < detail::repeat_n_c_ < N >>;
namespace detail
{
template < typename > struct at_impl_
{
template < typename T > static T eval ( T * );
};
template < typename, typename > struct at_;
template < typename ... Ts, typename N > struct at_ <list < Ts ... >,
N >:decltype ( at_impl_ < repeat_n <
N >>::eval ( _nullptr_v < id < Ts >> ( )... ) )
{
};
}
template < typename List, typename N > using at =
eval < detail::at_ < List, N >>;
template < typename List, std::size_t > using at_c =
at < List, size_t < 0 >>;
namespace detail
{
template < typename > struct back_;
template < typename Head,
typename ... List > struct back_ <list < Head, List ... >>
{
using type = at_c < list < Head >, sizeof ... ( List ) >;
};
}
template < typename List > using back = eval < detail::back_ < List >>;
namespace detail
{
template < typename, typename > struct push_front_;
template < typename ... List,
typename T > struct push_front_ <list < List ... >, T >
{
using type = list < T >;
};
}
template < typename List, typename T > using push_front =
eval < detail::push_front_ < List, T >>;
namespace detail
{
template < typename > struct push_back_;
}
template < typename, typename T > using push_back =
eval < detail::push_back_ < T >>;
namespace detail
{
template < typename > struct transform_;
}
template < typename ... Args > using transform =
eval < detail::transform_ < Args ... >>;
namespace detail
{
template < typename > struct is_valid_;
template < typename As, typename Ts > using substitutions_ =
push_back < join < transform < concat < repeat_n_c < size < Ts >
{
}
>>>>, list < back < As >>>;
template < typename Ts > using substitutions =
apply < if_c < size < Ts >
{
}
, quote < substitutions_ >>>;
template < typename > struct is_vararg_:std::false_type
{
};
template < typename Tags > using is_variadic_ =
is_vararg_ < at < push_front < Tags, void >, dec < size < Tags >>>>;
template < typename Tags, int =
is_variadic_ < Tags >::value > struct lambda_;
template < typename ... As > struct lambda_ <list < As ... >, false >
{
using Tags = list < As ... >;
using F = back < Tags >;
template < typename, typename > struct impl;
template < typename, typename > struct subst_;
template < template < typename ... >class C, typename ... Ts,
typename Args > struct subst_ <defer < C, Ts ... >, Args >
{
using type = C < eval < impl < Ts, Args >> ... >;
};
template < template < typename ... >class C, typename ... Ts,
typename Args > struct impl <defer < C, Ts ... >,
Args >:subst_ < defer < C >, Args >
{
};
template < typename ... Ts > using apply =
eval < if_c < sizeof ... ( Ts ), impl < F, list <>>>>;
};
}
template < typename ... Ts > using lambda =
if_c < sizeof ... ( Ts ), detail::lambda_ < list < Ts ... >>>;
template < typename T > using is_valid = detail::is_valid_ < T >;
namespace detail
{
template < typename ... >struct let_;
template < typename Fn > struct let_ <Fn >
{
using type = apply < lambda < Fn >>;
};
}
template < typename ... As > using let = eval < detail::let_ < As ... >>;
template < typename > struct common_reference_base;
template < typename ... >struct common_reference;
namespace detail
{
template < typename > struct builtin_common_impl;
template < typename U > using builtin_common_t =
meta::apply < builtin_common_impl < U >>;
template < typename, typename > using lazy_builtin_common_t =
meta::defer < builtin_common_t >;
template < typename > struct transform_reference;
template < typename, typename U > using common_reference_base_ =
common_reference_base < meta::eval < transform_reference < U >>>;
}
template < typename T, typename U > struct common_reference <T,
U >:meta::if_ < meta::let < meta::lazy::and_ < meta::is_valid <
detail::lazy_builtin_common_t < T, U >>,
meta::or_ < meta::not_ < meta::has_type <
detail::common_reference_base_ < T, U >>>>>>,
detail::lazy_builtin_common_t < T, U >,
detail::common_reference_base_ < T, U >>
{
};
}
}
|
