git.iko.soy/rowtype-yoga/purescript-native
on golang help sign in
C++: minor renaming in runtime
aba280fAndy Arvanitis
pcc/include/purescript.cc+79−79
compare with golang
unifiedsplit
@@ -17,70 +17,70 @@
17
17
18namespace PureScript {
18namespace PureScript {
19
19
20−#define RETURN_VALUE(TYPE, ACCESSOR, INDIRECTION) \
20+#define RETURN_VALUE(TAG, ACCESSOR, INDIRECTION) \
21 const any& variant = unthunkVariant(*this); \
21 const any& variant = unthunkVariant(*this); \
22− assert(variant.type == TYPE); \
22+ assert(variant.tag == TAG); \
23 return INDIRECTION(variant.ACCESSOR); \
23 return INDIRECTION(variant.ACCESSOR); \
24
24
25auto any::operator()(const any& arg) const -> any {
25auto any::operator()(const any& arg) const -> any {
26 const any& variant = unthunkVariant(*this);
26 const any& variant = unthunkVariant(*this);
27− if (variant.type == Type::Closure) {
27+ if (variant.tag == tag_t::Closure) {
28 return (*variant.l)(arg);
28 return (*variant.l)(arg);
29 }
29 }
30− assert(variant.type == Type::Function);
30+ assert(variant.tag == tag_t::Function);
31 return (*variant.f)(arg);
31 return (*variant.f)(arg);
32}
32}
33
33
34auto any::operator()(const as_thunk) const -> const any& {
34auto any::operator()(const as_thunk) const -> const any& {
35− assert(type == Type::Thunk);
35+ assert(tag == tag_t::Thunk);
36 return (*t)(unthunk);
36 return (*t)(unthunk);
37}
37}
38
38
39auto any::operator()() const -> any {
39auto any::operator()() const -> any {
40 const any& variant = unthunkVariant(*this);
40 const any& variant = unthunkVariant(*this);
41− if (variant.type == Type::EffClosure) {
41+ if (variant.tag == tag_t::EffClosure) {
42 return (*variant.k)();
42 return (*variant.k)();
43 }
43 }
44− assert(variant.type == Type::EffFunction);
44+ assert(variant.tag == tag_t::EffFunction);
45 return (*variant.e)();
45 return (*variant.e)();
46}
46}
47
47
48any::operator int() const {
48any::operator int() const {
49− RETURN_VALUE(Type::Integer, i,)
49+ RETURN_VALUE(tag_t::Integer, i,)
50}
50}
51
51
52any::operator double() const {
52any::operator double() const {
53− RETURN_VALUE(Type::Double, d,)
53+ RETURN_VALUE(tag_t::Double, d,)
54}
54}
55
55
56any::operator bool() const {
56any::operator bool() const {
57− RETURN_VALUE(Type::Boolean, b,)
57+ RETURN_VALUE(tag_t::Boolean, b,)
58}
58}
59
59
60any::operator char() const {
60any::operator char() const {
61− RETURN_VALUE(Type::Character, c,)
61+ RETURN_VALUE(tag_t::Character, c,)
62}
62}
63
63
64any::operator cstring() const {
64any::operator cstring() const {
65 const any& variant = unthunkVariant(*this);
65 const any& variant = unthunkVariant(*this);
66− if (variant.type == Type::StringLiteral) {
66+ if (variant.tag == tag_t::StringLiteral) {
67 return variant.r;
67 return variant.r;
68 }
68 }
69− assert(variant.type == Type::String);
69+ assert(variant.tag == tag_t::String);
70 return variant.s->c_str();
70 return variant.s->c_str();
71}
71}
72
72
73any::operator const array&() const {
73any::operator const array&() const {
74− RETURN_VALUE(Type::Array, a, *)
74+ RETURN_VALUE(tag_t::Array, a, *)
75}
75}
76
76
77−auto any::extractPointer(IF_DEBUG(const any::Type t)) const -> void* {
77+auto any::extractPointer(IF_DEBUG(const any::tag_t t)) const -> void* {
78 RETURN_VALUE(t, POINTER_FROM_MEMBER(p),)
78 RETURN_VALUE(t, POINTER_FROM_MEMBER(p),)
79}
79}
80
80
81auto any::unthunkVariant(const any& a) -> const any& {
81auto any::unthunkVariant(const any& a) -> const any& {
82 const any * variant = &a;
82 const any * variant = &a;
83− while (variant->type == Type::Thunk) {
83+ while (variant->tag == tag_t::Thunk) {
84 variant = &((*variant->t)(unthunk));
84 variant = &((*variant->t)(unthunk));
85 }
85 }
86 return *variant;
86 return *variant;
@@ -130,16 +130,16 @@ auto any::contains(const symbol_t key) const -> bool {
130#define DEFINE_CSTR_EQUALS_OPERATOR() \
130#define DEFINE_CSTR_EQUALS_OPERATOR() \
131 auto operator==(const any& lhs_, const char * rhs) -> bool { \
131 auto operator==(const any& lhs_, const char * rhs) -> bool { \
132 const any& lhs = any::unthunkVariant(lhs_); \
132 const any& lhs = any::unthunkVariant(lhs_); \
133− assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \
133+ assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String); \
134− if (lhs.type == any::Type::StringLiteral) { \
134+ if (lhs.tag == any::tag_t::StringLiteral) { \
135 return (lhs.r == rhs) || (strcmp(lhs.r, rhs) == 0); \
135 return (lhs.r == rhs) || (strcmp(lhs.r, rhs) == 0); \
136 } \
136 } \
137 return strcmp(lhs.s->c_str(), rhs) == 0; \
137 return strcmp(lhs.s->c_str(), rhs) == 0; \
138 } \
138 } \
139 auto operator==(const char * lhs, const any& rhs_) -> bool { \
139 auto operator==(const char * lhs, const any& rhs_) -> bool { \
140 const any& rhs = any::unthunkVariant(rhs_); \
140 const any& rhs = any::unthunkVariant(rhs_); \
141− assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \
141+ assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String); \
142− if (rhs.type == any::Type::StringLiteral) { \
142+ if (rhs.tag == any::tag_t::StringLiteral) { \
143 return (lhs == rhs.r) || (strcmp(lhs, rhs) == 0); \
143 return (lhs == rhs.r) || (strcmp(lhs, rhs) == 0); \
144 } \
144 } \
145 return strcmp(lhs, rhs.s->c_str()) == 0; \
145 return strcmp(lhs, rhs.s->c_str()) == 0; \
@@ -157,21 +157,21 @@ auto any::contains(const symbol_t key) const -> bool {
157 auto operator op (const any& lhs_, const any& rhs_) -> bool { \
157 auto operator op (const any& lhs_, const any& rhs_) -> bool { \
158 const any& lhs = any::unthunkVariant(lhs_); \
158 const any& lhs = any::unthunkVariant(lhs_); \
159 const any& rhs = any::unthunkVariant(rhs_); \
159 const any& rhs = any::unthunkVariant(rhs_); \
160− switch (lhs.type) { \
160+ switch (lhs.tag) { \
161− case any::Type::Integer: assert(lhs.type == any::Type::Integer); return lhs.i op rhs.i; \
161+ case any::tag_t::Integer: assert(lhs.tag == any::tag_t::Integer); return lhs.i op rhs.i; \
162− case any::Type::Double: assert(lhs.type == any::Type::Double); return lhs.d op rhs.d; \
162+ case any::tag_t::Double: assert(lhs.tag == any::tag_t::Double); return lhs.d op rhs.d; \
163− case any::Type::Character: assert(lhs.type == any::Type::Character); return lhs.c op rhs.c; \
163+ case any::tag_t::Character: assert(lhs.tag == any::tag_t::Character); return lhs.c op rhs.c; \
164− case any::Type::Boolean: assert(lhs.type == any::Type::Boolean); return lhs.b op rhs.b; \
164+ case any::tag_t::Boolean: assert(lhs.tag == any::tag_t::Boolean); return lhs.b op rhs.b; \
165− case any::Type::StringLiteral: \
165+ case any::tag_t::StringLiteral: \
166− assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \
166+ assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String); \
167− assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \
167+ assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String); \
168− return strcmp(lhs.r, rhs.type == any::Type::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
168+ return strcmp(lhs.r, rhs.tag == any::tag_t::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
169− case any::Type::String: \
169+ case any::tag_t::String: \
170− assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \
170+ assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String); \
171− assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \
171+ assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String); \
172− return strcmp(lhs.s->c_str(), rhs.type == any::Type::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
172+ return strcmp(lhs.s->c_str(), rhs.tag == any::tag_t::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
173− case any::Type::Pointer: return lhs.p op rhs.p; \
173+ case any::tag_t::Pointer: return lhs.p op rhs.p; \
174− default: assert(false && "Unsupported type for operator " #op); \
174+ default: assert(false && "Unsupported tag for operator " #op); \
175 } \
175 } \
176 return false; \
176 return false; \
177 }
177 }
@@ -197,44 +197,44 @@ DEFINE_CSTR_COMPARISON_OPERATOR(>=)
197auto operator+(const any& lhs_, const any& rhs_) -> any {
197auto operator+(const any& lhs_, const any& rhs_) -> any {
198 const any& lhs = any::unthunkVariant(lhs_);
198 const any& lhs = any::unthunkVariant(lhs_);
199 const any& rhs = any::unthunkVariant(rhs_);
199 const any& rhs = any::unthunkVariant(rhs_);
200− switch (lhs.type) {
200+ switch (lhs.tag) {
201− case any::Type::Integer: assert(lhs.type == any::Type::Integer); return lhs.i + rhs.i;
201+ case any::tag_t::Integer: assert(lhs.tag == any::tag_t::Integer); return lhs.i + rhs.i;
202− case any::Type::Double: assert(lhs.type == any::Type::Double); return lhs.d + rhs.d;
202+ case any::tag_t::Double: assert(lhs.tag == any::tag_t::Double); return lhs.d + rhs.d;
203− case any::Type::Character: assert(lhs.type == any::Type::Character); return any(char(lhs.c + rhs.c));
203+ case any::tag_t::Character: assert(lhs.tag == any::tag_t::Character); return any(char(lhs.c + rhs.c));
204− case any::Type::StringLiteral:
204+ case any::tag_t::StringLiteral:
205− assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);
205+ assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String);
206− assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);
206+ assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String);
207− return rhs.type == any::Type::StringLiteral ? std::string(lhs.r) + rhs.r : lhs.r + *rhs.s;
207+ return rhs.tag == any::tag_t::StringLiteral ? std::string(lhs.r) + rhs.r : lhs.r + *rhs.s;
208− case any::Type::String:
208+ case any::tag_t::String:
209− assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);
209+ assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String);
210− assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);
210+ assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String);
211− return rhs.type == any::Type::StringLiteral ? *lhs.s + rhs.r : *lhs.s + *rhs.s;
211+ return rhs.tag == any::tag_t::StringLiteral ? *lhs.s + rhs.r : *lhs.s + *rhs.s;
212− default: assert(false && "Unsupported type for '+' operator");
212+ default: assert(false && "Unsupported tag for '+' operator");
213 }
213 }
214 return nullptr;
214 return nullptr;
215}
215}
216
216
217auto operator+(const any& lhs_, const char * rhs) -> std::string {
217auto operator+(const any& lhs_, const char * rhs) -> std::string {
218 const any& lhs = any::unthunkVariant(lhs_);
218 const any& lhs = any::unthunkVariant(lhs_);
219− assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);
219+ assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String);
220− return lhs.type == any::Type::StringLiteral ? std::string(lhs.r) + rhs : *lhs.s + rhs;
220+ return lhs.tag == any::tag_t::StringLiteral ? std::string(lhs.r) + rhs : *lhs.s + rhs;
221}
221}
222
222
223auto operator+(const char * lhs, const any& rhs_) -> std::string {
223auto operator+(const char * lhs, const any& rhs_) -> std::string {
224 const any& rhs = any::unthunkVariant(rhs_);
224 const any& rhs = any::unthunkVariant(rhs_);
225− assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);
225+ assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String);
226− return rhs.type == any::Type::StringLiteral ? lhs + std::string(rhs.r) : lhs + *rhs.s;
226+ return rhs.tag == any::tag_t::StringLiteral ? lhs + std::string(rhs.r) : lhs + *rhs.s;
227}
227}
228
228
229auto operator-(const any& lhs_, const any& rhs_) -> any {
229auto operator-(const any& lhs_, const any& rhs_) -> any {
230 const any& lhs = any::unthunkVariant(lhs_);
230 const any& lhs = any::unthunkVariant(lhs_);
231 const any& rhs = any::unthunkVariant(rhs_);
231 const any& rhs = any::unthunkVariant(rhs_);
232− assert(lhs.type == rhs.type);
232+ assert(lhs.tag == rhs.tag);
233− switch (lhs.type) {
233+ switch (lhs.tag) {
234− case any::Type::Integer: return lhs.i - rhs.i;
234+ case any::tag_t::Integer: return lhs.i - rhs.i;
235− case any::Type::Double: return lhs.d - rhs.d;
235+ case any::tag_t::Double: return lhs.d - rhs.d;
236− case any::Type::Character: return any(char(lhs.c - rhs.c));
236+ case any::tag_t::Character: return any(char(lhs.c - rhs.c));
237− default: assert(false && "Unsupported type for '-' operator");
237+ default: assert(false && "Unsupported tag for '-' operator");
238 }
238 }
239 return nullptr;
239 return nullptr;
240}
240}
@@ -242,12 +242,12 @@ auto operator-(const any& lhs_, const any& rhs_) -> any {
242auto operator*(const any& lhs_, const any& rhs_) -> any {
242auto operator*(const any& lhs_, const any& rhs_) -> any {
243 const any& lhs = any::unthunkVariant(lhs_);
243 const any& lhs = any::unthunkVariant(lhs_);
244 const any& rhs = any::unthunkVariant(rhs_);
244 const any& rhs = any::unthunkVariant(rhs_);
245− assert(lhs.type == rhs.type);
245+ assert(lhs.tag == rhs.tag);
246− switch (lhs.type) {
246+ switch (lhs.tag) {
247− case any::Type::Integer: return lhs.i * rhs.i;
247+ case any::tag_t::Integer: return lhs.i * rhs.i;
248− case any::Type::Double: return lhs.d * rhs.d;
248+ case any::tag_t::Double: return lhs.d * rhs.d;
249− case any::Type::Character: return any(char(lhs.c * rhs.c));
249+ case any::tag_t::Character: return any(char(lhs.c * rhs.c));
250− default: assert(false && "Unsupported type for '*' operator");
250+ default: assert(false && "Unsupported tag for '*' operator");
251 }
251 }
252 return nullptr;
252 return nullptr;
253}
253}
@@ -255,12 +255,12 @@ auto operator*(const any& lhs_, const any& rhs_) -> any {
255auto operator/(const any& lhs_, const any& rhs_) -> any {
255auto operator/(const any& lhs_, const any& rhs_) -> any {
256 const any& lhs = any::unthunkVariant(lhs_);
256 const any& lhs = any::unthunkVariant(lhs_);
257 const any& rhs = any::unthunkVariant(rhs_);
257 const any& rhs = any::unthunkVariant(rhs_);
258− assert(lhs.type == rhs.type);
258+ assert(lhs.tag == rhs.tag);
259− switch (lhs.type) {
259+ switch (lhs.tag) {
260− case any::Type::Integer: return lhs.i / rhs.i;
260+ case any::tag_t::Integer: return lhs.i / rhs.i;
261− case any::Type::Double: return lhs.d / rhs.d;
261+ case any::tag_t::Double: return lhs.d / rhs.d;
262− case any::Type::Character: return any(char(lhs.c / rhs.c));
262+ case any::tag_t::Character: return any(char(lhs.c / rhs.c));
263− default: assert(false && "Unsupported type for '/' operator");
263+ default: assert(false && "Unsupported tag for '/' operator");
264 }
264 }
265 return nullptr;
265 return nullptr;
266}
266}
@@ -268,11 +268,11 @@ auto operator/(const any& lhs_, const any& rhs_) -> any {
268auto operator%(const any& lhs_, const any& rhs_) -> any {
268auto operator%(const any& lhs_, const any& rhs_) -> any {
269 const any& lhs = any::unthunkVariant(lhs_);
269 const any& lhs = any::unthunkVariant(lhs_);
270 const any& rhs = any::unthunkVariant(rhs_);
270 const any& rhs = any::unthunkVariant(rhs_);
271− assert(lhs.type == rhs.type);
271+ assert(lhs.tag == rhs.tag);
272− switch (lhs.type) {
272+ switch (lhs.tag) {
273− case any::Type::Integer: return lhs.i % rhs.i;
273+ case any::tag_t::Integer: return lhs.i % rhs.i;
274− case any::Type::Character: return any(char(lhs.c % rhs.c));
274+ case any::tag_t::Character: return any(char(lhs.c % rhs.c));
275− default: assert(false && "Unsupported type for '%' operator");
275+ default: assert(false && "Unsupported tag for '%' operator");
276 }
276 }
277 return nullptr;
277 return nullptr;
278}
278}
@@ -280,10 +280,10 @@ auto operator%(const any& lhs_, const any& rhs_) -> any {
280// unary negate
280// unary negate
281auto operator-(const any& rhs_) -> any {
281auto operator-(const any& rhs_) -> any {
282 const any& rhs = any::unthunkVariant(rhs_);
282 const any& rhs = any::unthunkVariant(rhs_);
283− switch (rhs.type) {
283+ switch (rhs.tag) {
284− case any::Type::Integer: return (- rhs.i);
284+ case any::tag_t::Integer: return (- rhs.i);
285− case any::Type::Double: return (- rhs.d);
285+ case any::tag_t::Double: return (- rhs.d);
286− default: assert(false && "Unsupported type for unary '-' operator");
286+ default: assert(false && "Unsupported tag for unary '-' operator");
287 }
287 }
288 return nullptr;
288 return nullptr;
289}
289}
pcc/include/purescript.hh+63−63
@@ -71,7 +71,7 @@ static constexpr size_t unknown_size = 64;
71class any {
71class any {
72
72
73 public:
73 public:
74− enum class Type {
74+ enum class tag_t {
75 Thunk = 0x10,
75 Thunk = 0x10,
76 Integer,
76 Integer,
77 Double,
77 Double,
@@ -91,7 +91,7 @@ class any {
91 };
91 };
92
92
93 private:
93 private:
94− mutable Type type;
94+ mutable tag_t tag;
95
95
96 public:
96 public:
97 struct as_thunk {
97 struct as_thunk {
@@ -164,74 +164,74 @@ class any {
164
164
165 public:
165 public:
166
166
167− any(const int val) noexcept : type(Type::Integer), i(val) {}
167+ any(const int val) noexcept : tag(tag_t::Integer), i(val) {}
168− any(const long int_value) noexcept : type(Type::Integer), i(int_value) {
168+ any(const long int_value) noexcept : tag(tag_t::Integer), i(int_value) {
169 assert(int_value >= INT_MIN && int_value <= INT_MAX);
169 assert(int_value >= INT_MIN && int_value <= INT_MAX);
170 }
170 }
171
171
172− any(const double val) noexcept : type(Type::Double), d(val) {}
172+ any(const double val) noexcept : tag(tag_t::Double), d(val) {}
173− any(const char val) noexcept : type(Type::Character), c(val) {}
173+ any(const char val) noexcept : tag(tag_t::Character), c(val) {}
174
174
175 template <typename T, typename = typename std::enable_if<std::is_same<bool,T>::value>::type>
175 template <typename T, typename = typename std::enable_if<std::is_same<bool,T>::value>::type>
176− any(const T val) noexcept : type(Type::Boolean), b(val) {}
176+ any(const T val) noexcept : tag(tag_t::Boolean), b(val) {}
177
177
178 template <size_t N>
178 template <size_t N>
179− any(const char (&val)[N]) noexcept : type(Type::StringLiteral), r(val) {}
179+ any(const char (&val)[N]) noexcept : tag(tag_t::StringLiteral), r(val) {}
180− any(char * val) : type(Type::String), s(make_managed<std::string>(val)) {}
180+ any(char * val) : tag(tag_t::String), s(make_managed<std::string>(val)) {}
181
181
182− any(const std::string& val) : type(Type::String), s(make_managed<std::string>(val)) {}
182+ any(const std::string& val) : tag(tag_t::String), s(make_managed<std::string>(val)) {}
183− any(std::string&& val) noexcept : type(Type::String), s(make_managed<std::string>(std::move(val))) {}
183+ any(std::string&& val) noexcept : tag(tag_t::String), s(make_managed<std::string>(std::move(val))) {}
184
184
185− any(const managed<std::string>& val) noexcept : type(Type::String), s(val) {}
185+ any(const managed<std::string>& val) noexcept : tag(tag_t::String), s(val) {}
186− any(managed<std::string>&& val) noexcept : type(Type::String), s(std::move(val)) {}
186+ any(managed<std::string>&& val) noexcept : tag(tag_t::String), s(std::move(val)) {}
187
187
188 template <size_t N>
188 template <size_t N>
189− any(map<N>&& val) noexcept : type(Type::Map), p(make_managed<map<N>>(std::move(val))) {}
189+ any(map<N>&& val) noexcept : tag(tag_t::Map), p(make_managed<map<N>>(std::move(val))) {}
190
190
191 template <size_t N>
191 template <size_t N>
192− any(data<N>&& val) noexcept : type(Type::Data), p(make_managed<data<N>>(std::move(val))) {}
192+ any(data<N>&& val) noexcept : tag(tag_t::Data), p(make_managed<data<N>>(std::move(val))) {}
193
193
194− any(const array& val) : type(Type::Array), a(make_managed<array>(val)) {}
194+ any(const array& val) : tag(tag_t::Array), a(make_managed<array>(val)) {}
195− any(array&& val) noexcept : type(Type::Array), a(make_managed<array>(std::move(val))) {}
195+ any(array&& val) noexcept : tag(tag_t::Array), a(make_managed<array>(std::move(val))) {}
196
196
197 template <typename T>
197 template <typename T>
198 any(const T& val, typename std::enable_if<std::is_convertible<T,fn>::value>::type* = 0) noexcept
198 any(const T& val, typename std::enable_if<std::is_convertible<T,fn>::value>::type* = 0) noexcept
199− : type(Type::Function), f(val) {}
199+ : tag(tag_t::Function), f(val) {}
200
200
201 template <typename T, typename = typename std::enable_if<!std::is_same<any,T>::value &&
201 template <typename T, typename = typename std::enable_if<!std::is_same<any,T>::value &&
202 !std::is_convertible<T,fn>::value>::type>
202 !std::is_convertible<T,fn>::value>::type>
203 any(const T& val, typename std::enable_if<std::is_assignable<std::function<any(const any&)>,T>::value>::type* = 0)
203 any(const T& val, typename std::enable_if<std::is_assignable<std::function<any(const any&)>,T>::value>::type* = 0)
204− : type(Type::Closure), l(make_managed<_closure<T>>(val)) {}
204+ : tag(tag_t::Closure), l(make_managed<_closure<T>>(val)) {}
205
205
206 template <typename T>
206 template <typename T>
207 any(const T& val, typename std::enable_if<std::is_convertible<T,eff_fn>::value>::type* = 0) noexcept
207 any(const T& val, typename std::enable_if<std::is_convertible<T,eff_fn>::value>::type* = 0) noexcept
208− : type(Type::EffFunction), e(val) {}
208+ : tag(tag_t::EffFunction), e(val) {}
209
209
210 template <typename T,
210 template <typename T,
211 typename = typename std::enable_if<!std::is_same<any,T>::value &&
211 typename = typename std::enable_if<!std::is_same<any,T>::value &&
212 !std::is_convertible<T,eff_fn>::value>::type>
212 !std::is_convertible<T,eff_fn>::value>::type>
213 any(const T& val, typename std::enable_if<std::is_assignable<std::function<any()>,T>::value>::type* = 0)
213 any(const T& val, typename std::enable_if<std::is_assignable<std::function<any()>,T>::value>::type* = 0)
214− : type(Type::EffClosure), k(make_managed<_eff_closure<T>>(val)) {}
214+ : tag(tag_t::EffClosure), k(make_managed<_eff_closure<T>>(val)) {}
215
215
216 template <typename T>
216 template <typename T>
217 any(const T& val, typename std::enable_if<std::is_convertible<T,thunk>::value>::type* = 0) noexcept
217 any(const T& val, typename std::enable_if<std::is_convertible<T,thunk>::value>::type* = 0) noexcept
218− : type(Type::Thunk), t(val) {}
218+ : tag(tag_t::Thunk), t(val) {}
219
219
220 template <typename T,
220 template <typename T,
221 typename = typename std::enable_if<std::is_class<typename std::remove_pointer<T>::type>::value>::type>
221 typename = typename std::enable_if<std::is_class<typename std::remove_pointer<T>::type>::value>::type>
222 any(const T& val, typename std::enable_if<IS_POINTER_TYPE(T)::value>::type* = 0) noexcept
222 any(const T& val, typename std::enable_if<IS_POINTER_TYPE(T)::value>::type* = 0) noexcept
223− : type(Type::Pointer), p(val) {}
223+ : tag(tag_t::Pointer), p(val) {}
224
224
225 template <typename T>
225 template <typename T>
226 any(T&& val, typename std::enable_if<std::is_assignable<managed<void>,T>::value>::type* = 0) noexcept
226 any(T&& val, typename std::enable_if<std::is_assignable<managed<void>,T>::value>::type* = 0) noexcept
227− : type(Type::Pointer), p(std::move(val)) {}
227+ : tag(tag_t::Pointer), p(std::move(val)) {}
228
228
229 // Explicit void* to raw pointer value
229 // Explicit void* to raw pointer value
230 template <typename T>
230 template <typename T>
231 any(const T& val, typename std::enable_if<std::is_same<T,void*>::value>::type* = 0) noexcept
231 any(const T& val, typename std::enable_if<std::is_same<T,void*>::value>::type* = 0) noexcept
232− : type(Type::RawPointer), u(val) {}
232+ : tag(tag_t::RawPointer), u(val) {}
233
233
234− any(nullptr_t) noexcept : type(Type::RawPointer), u(nullptr) {}
234+ any(nullptr_t) noexcept : tag(tag_t::RawPointer), u(nullptr) {}
235
235
236
236
237#if !defined(USE_GC)
237#if !defined(USE_GC)
@@ -252,62 +252,62 @@ class any {
252
252
253 template <typename T>
253 template <typename T>
254 auto assign(T&& other) const noexcept -> void {
254 auto assign(T&& other) const noexcept -> void {
255− switch (other.type) {
255+ switch (other.tag) {
256− case Type::Thunk: t = other.t; break;
256+ case tag_t::Thunk: t = other.t; break;
257− case Type::Integer: i = other.i; break;
257+ case tag_t::Integer: i = other.i; break;
258− case Type::Double: d = other.d; break;
258+ case tag_t::Double: d = other.d; break;
259− case Type::Character: c = other.c; break;
259+ case tag_t::Character: c = other.c; break;
260− case Type::Boolean: b = other.b; break;
260+ case tag_t::Boolean: b = other.b; break;
261− case Type::StringLiteral: r = other.r; break;
261+ case tag_t::StringLiteral: r = other.r; break;
262− case Type::Function: f = other.f; break;
262+ case tag_t::Function: f = other.f; break;
263− case Type::EffFunction: e = other.e; break;
263+ case tag_t::EffFunction: e = other.e; break;
264− case Type::RawPointer: u = other.u; break;
264+ case tag_t::RawPointer: u = other.u; break;
265−
265+
266− case Type::String: new (&s) managed<std::string>(move_if_rvalue<T>(other.s)); break;
266+ case tag_t::String: new (&s) managed<std::string>(move_if_rvalue<T>(other.s)); break;
267− case Type::Array: new (&a) managed<array>(move_if_rvalue<T>(other.a)); break;
267+ case tag_t::Array: new (&a) managed<array>(move_if_rvalue<T>(other.a)); break;
268− case Type::Closure: new (&l) managed<closure>(move_if_rvalue<T>(other.l)); break;
268+ case tag_t::Closure: new (&l) managed<closure>(move_if_rvalue<T>(other.l)); break;
269− case Type::EffClosure: new (&k) managed<eff_closure>(move_if_rvalue<T>(other.k)); break;
269+ case tag_t::EffClosure: new (&k) managed<eff_closure>(move_if_rvalue<T>(other.k)); break;
270− case Type::Map:
270+ case tag_t::Map:
271− case Type::Data:
271+ case tag_t::Data:
272− case Type::Pointer: new (&p) managed<void>(move_if_rvalue<T>(other.p)); break;
272+ case tag_t::Pointer: new (&p) managed<void>(move_if_rvalue<T>(other.p)); break;
273−
273+
274− default: assert(false && "Bad 'any' type"); break;
274+ default: assert(false && "Bad 'any' tag"); break;
275 }
275 }
276 }
276 }
277
277
278 auto destruct() -> void {
278 auto destruct() -> void {
279− switch (type) {
279+ switch (tag) {
280− case Type::String: s.~managed<std::string>(); break;
280+ case tag_t::String: s.~managed<std::string>(); break;
281− case Type::Array: a.~managed<array>(); break;
281+ case tag_t::Array: a.~managed<array>(); break;
282− case Type::Closure: l.~managed<closure>(); break;
282+ case tag_t::Closure: l.~managed<closure>(); break;
283− case Type::EffClosure: k.~managed<eff_closure>(); break;
283+ case tag_t::EffClosure: k.~managed<eff_closure>(); break;
284− case Type::Map:
284+ case tag_t::Map:
285− case Type::Data:
285+ case tag_t::Data:
286− case Type::Pointer: p.~managed<void>(); break;
286+ case tag_t::Pointer: p.~managed<void>(); break;
287
287
288 default: break;
288 default: break;
289 }
289 }
290 }
290 }
291
291
292 public:
292 public:
293− any(const any& other) noexcept : type(other.type) {
293+ any(const any& other) noexcept : tag(other.tag) {
294 assign(other);
294 assign(other);
295 }
295 }
296
296
297− any(any&& other) noexcept : type(other.type) {
297+ any(any&& other) noexcept : tag(other.tag) {
298 assign(std::move(other));
298 assign(std::move(other));
299 }
299 }
300
300
301 auto operator=(const any& rhs) noexcept -> any& {
301 auto operator=(const any& rhs) noexcept -> any& {
302 destruct();
302 destruct();
303− type = rhs.type;
303+ tag = rhs.tag;
304 assign(rhs);
304 assign(rhs);
305 return *this;
305 return *this;
306 }
306 }
307
307
308 auto operator=(any&& rhs) noexcept -> any& {
308 auto operator=(any&& rhs) noexcept -> any& {
309 destruct();
309 destruct();
310− type = rhs.type;
310+ tag = rhs.tag;
311 assign(std::move(rhs));
311 assign(std::move(rhs));
312 return *this;
312 return *this;
313 }
313 }
@@ -337,11 +337,11 @@ class any {
337
337
338 auto contains(const symbol_t) const -> bool;
338 auto contains(const symbol_t) const -> bool;
339
339
340− auto extractPointer(IF_DEBUG(const Type)) const -> void*;
340+ auto extractPointer(IF_DEBUG(const tag_t)) const -> void*;
341
341
342 auto rawPointer() const -> void* {
342 auto rawPointer() const -> void* {
343 const any& variant = unthunkVariant(*this);
343 const any& variant = unthunkVariant(*this);
344− assert(type == Type::RawPointer);
344+ assert(tag == tag_t::RawPointer);
345 return variant.u;
345 return variant.u;
346 }
346 }
347
347
@@ -411,17 +411,17 @@ struct tag_helper {};
411
411
412template <size_t N>
412template <size_t N>
413struct tag_helper<any::map<N>> {
413struct tag_helper<any::map<N>> {
414− static constexpr any::Type tag = any::Type::Map;
414+ static constexpr any::tag_t tag = any::tag_t::Map;
415};
415};
416
416
417template <size_t N>
417template <size_t N>
418struct tag_helper<any::data<N>> {
418struct tag_helper<any::data<N>> {
419− static constexpr any::Type tag = any::Type::Data;
419+ static constexpr any::tag_t tag = any::tag_t::Data;
420};
420};
421
421
422template <typename T>
422template <typename T>
423struct tag_helper<T> {
423struct tag_helper<T> {
424− static constexpr any::Type tag = any::Type::Pointer;
424+ static constexpr any::tag_t tag = any::tag_t::Pointer;
425};
425};
426
426
427template <typename T>
427template <typename T>