git.iko.soy/rowtype-yoga/purescript-native
on golang help sign in
C++: clean up some private type names in the runtime
commitde13186d4a7be6cc7358b46650240287fa31831d authorAndy Arvanitis <andyarvanitis@gmail.com> dateFri 23 Dec 2016, 14:10 (10 years ago) parent81aa981
3 files changed+145−146
compare with golang
unifiedsplit
pcc/runtime/purescript.cc+62−62 pcc/runtime/purescript.hh+83−83 src/Language/PureScript/CodeGen/Cpp/Common.hs−1
pcc/runtime/purescript.cc+62−62
@@ -17,8 +17,8 @@
1717
1818namespace PureScript {
1919
20−any::closure::~closure() {}
21−any::eff_closure::~eff_closure() {}
20+any::Closure::~Closure() {}
21+any::EffClosure::~EffClosure() {}
2222
2323#define RETURN_VALUE(TAG, ACCESSOR, INDIRECTION) \
2424 const any& variant = unthunkVariant(*this); \
@@ -27,41 +27,41 @@ any::eff_closure::~eff_closure() {}
2727
2828auto any::operator()(const any& arg) const -> any {
2929 const any& variant = unthunkVariant(*this);
30− if (variant.tag == tag_t::Closure) {
30+ if (variant.tag == Tag::Closure) {
3131 return (*variant.l)(arg);
3232 }
33− assert(variant.tag == tag_t::Function);
33+ assert(variant.tag == Tag::Function);
3434 return (*variant.f)(arg);
3535}
3636
3737auto any::operator()(const as_thunk) const -> const any& {
38− assert(tag == tag_t::Thunk);
38+ assert(tag == Tag::Thunk);
3939 return (*t)(unthunk);
4040}
4141
4242auto any::operator()() const -> any {
4343 const any& variant = unthunkVariant(*this);
44− if (variant.tag == tag_t::EffClosure) {
44+ if (variant.tag == Tag::EffClosure) {
4545 return (*variant.k)();
4646 }
47− assert(variant.tag == tag_t::EffFunction);
47+ assert(variant.tag == Tag::EffFunction);
4848 return (*variant.e)();
4949}
5050
5151any::operator int() const {
52− RETURN_VALUE(tag_t::Integer, i,)
52+ RETURN_VALUE(Tag::Integer, i,)
5353}
5454
5555any::operator double() const {
56− RETURN_VALUE(tag_t::Double, d,)
56+ RETURN_VALUE(Tag::Double, d,)
5757}
5858
5959any::operator bool() const {
60− RETURN_VALUE(tag_t::Boolean, b,)
60+ RETURN_VALUE(Tag::Boolean, b,)
6161}
6262
6363any::operator char() const {
64− RETURN_VALUE(tag_t::Character, c,)
64+ RETURN_VALUE(Tag::Character, c,)
6565}
6666
6767any::operator size_t() const {
@@ -72,24 +72,24 @@ any::operator size_t() const {
7272
7373any::operator cstring() const {
7474 const any& variant = unthunkVariant(*this);
75− if (variant.tag == tag_t::StringLiteral) {
75+ if (variant.tag == Tag::StringLiteral) {
7676 return variant.r;
7777 }
78− assert(variant.tag == tag_t::String);
78+ assert(variant.tag == Tag::String);
7979 return variant.s->c_str();
8080}
8181
8282any::operator const array&() const {
83− RETURN_VALUE(tag_t::Array, a, *)
83+ RETURN_VALUE(Tag::Array, a, *)
8484}
8585
86−auto any::extractPointer(IF_DEBUG(const any::tag_t t)) const -> void* {
86+auto any::extractPointer(IF_DEBUG(const any::Tag t)) const -> void* {
8787 RETURN_VALUE(t, POINTER_FROM_MEMBER(p),)
8888}
8989
9090auto any::unthunkVariant(const any& a) -> const any& {
9191 const any * variant = &a;
92− while (variant->tag == tag_t::Thunk) {
92+ while (variant->tag == Tag::Thunk) {
9393 variant = &((*variant->t)(unthunk));
9494 }
9595 return *variant;
@@ -108,7 +108,7 @@ auto any::empty() const -> bool {
108108 return cast<array>(*this).empty();
109109}
110110
111−auto any::contains(const symbol_t key) const -> bool {
111+auto any::contains(const Private::Symbol key) const -> bool {
112112 // TODO: assumes at least one element -- safe assumption?
113113 const auto& m = cast<map<unknown_size>>(*this);
114114 std::remove_reference<decltype(m)>::type::size_type i = 0;
@@ -127,16 +127,16 @@ auto any::contains(const symbol_t key) const -> bool {
127127#define DEFINE_CSTR_EQUALS_OPERATOR() \
128128 auto operator==(const any& lhs_, const char * rhs) -> bool { \
129129 const any& lhs = any::unthunkVariant(lhs_); \
130− assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String); \
131− if (lhs.tag == any::tag_t::StringLiteral) { \
130+ assert(lhs.tag == any::Tag::StringLiteral || lhs.tag == any::Tag::String); \
131+ if (lhs.tag == any::Tag::StringLiteral) { \
132132 return (lhs.r == rhs) || (strcmp(lhs.r, rhs) == 0); \
133133 } \
134134 return strcmp(lhs.s->c_str(), rhs) == 0; \
135135 } \
136136 auto operator==(const char * lhs, const any& rhs_) -> bool { \
137137 const any& rhs = any::unthunkVariant(rhs_); \
138− assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String); \
139− if (rhs.tag == any::tag_t::StringLiteral) { \
138+ assert(rhs.tag == any::Tag::StringLiteral || rhs.tag == any::Tag::String); \
139+ if (rhs.tag == any::Tag::StringLiteral) { \
140140 return (lhs == rhs.r) || (strcmp(lhs, rhs) == 0); \
141141 } \
142142 return strcmp(lhs, rhs.s->c_str()) == 0; \
@@ -155,19 +155,19 @@ auto any::contains(const symbol_t key) const -> bool {
155155 const any& lhs = any::unthunkVariant(lhs_); \
156156 const any& rhs = any::unthunkVariant(rhs_); \
157157 switch (lhs.tag) { \
158− case any::tag_t::Integer: assert(lhs.tag == any::tag_t::Integer); return lhs.i op rhs.i; \
159− case any::tag_t::Double: assert(lhs.tag == any::tag_t::Double); return lhs.d op rhs.d; \
160− case any::tag_t::Character: assert(lhs.tag == any::tag_t::Character); return lhs.c op rhs.c; \
161− case any::tag_t::Boolean: assert(lhs.tag == any::tag_t::Boolean); return lhs.b op rhs.b; \
162− case any::tag_t::StringLiteral: \
163− assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String); \
164− assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String); \
165− return strcmp(lhs.r, rhs.tag == any::tag_t::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
166− case any::tag_t::String: \
167− assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String); \
168− assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String); \
169− return strcmp(lhs.s->c_str(), rhs.tag == any::tag_t::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
170− case any::tag_t::Pointer: return lhs.p op rhs.p; \
158+ case any::Tag::Integer: assert(lhs.tag == any::Tag::Integer); return lhs.i op rhs.i; \
159+ case any::Tag::Double: assert(lhs.tag == any::Tag::Double); return lhs.d op rhs.d; \
160+ case any::Tag::Character: assert(lhs.tag == any::Tag::Character); return lhs.c op rhs.c; \
161+ case any::Tag::Boolean: assert(lhs.tag == any::Tag::Boolean); return lhs.b op rhs.b; \
162+ case any::Tag::StringLiteral: \
163+ assert(lhs.tag == any::Tag::StringLiteral || lhs.tag == any::Tag::String); \
164+ assert(rhs.tag == any::Tag::StringLiteral || rhs.tag == any::Tag::String); \
165+ return strcmp(lhs.r, rhs.tag == any::Tag::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
166+ case any::Tag::String: \
167+ assert(lhs.tag == any::Tag::StringLiteral || lhs.tag == any::Tag::String); \
168+ assert(rhs.tag == any::Tag::StringLiteral || rhs.tag == any::Tag::String); \
169+ return strcmp(lhs.s->c_str(), rhs.tag == any::Tag::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \
170+ case any::Tag::Pointer: return lhs.p op rhs.p; \
171171 default: assert(false && "Unsupported tag for operator " #op); \
172172 } \
173173 return false; \
@@ -195,17 +195,17 @@ auto operator+(const any& lhs_, const any& rhs_) -> any {
195195 const any& lhs = any::unthunkVariant(lhs_);
196196 const any& rhs = any::unthunkVariant(rhs_);
197197 switch (lhs.tag) {
198− case any::tag_t::Integer: assert(lhs.tag == any::tag_t::Integer); return lhs.i + rhs.i;
199− case any::tag_t::Double: assert(lhs.tag == any::tag_t::Double); return lhs.d + rhs.d;
200− case any::tag_t::Character: assert(lhs.tag == any::tag_t::Character); return any(char(lhs.c + rhs.c));
201− case any::tag_t::StringLiteral:
202− assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String);
203− assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String);
204− return rhs.tag == any::tag_t::StringLiteral ? std::string(lhs.r) + rhs.r : lhs.r + *rhs.s;
205− case any::tag_t::String:
206− assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String);
207− assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String);
208− return rhs.tag == any::tag_t::StringLiteral ? *lhs.s + rhs.r : *lhs.s + *rhs.s;
198+ case any::Tag::Integer: assert(lhs.tag == any::Tag::Integer); return lhs.i + rhs.i;
199+ case any::Tag::Double: assert(lhs.tag == any::Tag::Double); return lhs.d + rhs.d;
200+ case any::Tag::Character: assert(lhs.tag == any::Tag::Character); return any(char(lhs.c + rhs.c));
201+ case any::Tag::StringLiteral:
202+ assert(lhs.tag == any::Tag::StringLiteral || lhs.tag == any::Tag::String);
203+ assert(rhs.tag == any::Tag::StringLiteral || rhs.tag == any::Tag::String);
204+ return rhs.tag == any::Tag::StringLiteral ? std::string(lhs.r) + rhs.r : lhs.r + *rhs.s;
205+ case any::Tag::String:
206+ assert(lhs.tag == any::Tag::StringLiteral || lhs.tag == any::Tag::String);
207+ assert(rhs.tag == any::Tag::StringLiteral || rhs.tag == any::Tag::String);
208+ return rhs.tag == any::Tag::StringLiteral ? *lhs.s + rhs.r : *lhs.s + *rhs.s;
209209 default: assert(false && "Unsupported tag for '+' operator");
210210 }
211211 return nullptr;
@@ -213,14 +213,14 @@ auto operator+(const any& lhs_, const any& rhs_) -> any {
213213
214214auto operator+(const any& lhs_, const char * rhs) -> std::string {
215215 const any& lhs = any::unthunkVariant(lhs_);
216− assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String);
217− return lhs.tag == any::tag_t::StringLiteral ? std::string(lhs.r) + rhs : *lhs.s + rhs;
216+ assert(lhs.tag == any::Tag::StringLiteral || lhs.tag == any::Tag::String);
217+ return lhs.tag == any::Tag::StringLiteral ? std::string(lhs.r) + rhs : *lhs.s + rhs;
218218}
219219
220220auto operator+(const char * lhs, const any& rhs_) -> std::string {
221221 const any& rhs = any::unthunkVariant(rhs_);
222− assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String);
223− return rhs.tag == any::tag_t::StringLiteral ? lhs + std::string(rhs.r) : lhs + *rhs.s;
222+ assert(rhs.tag == any::Tag::StringLiteral || rhs.tag == any::Tag::String);
223+ return rhs.tag == any::Tag::StringLiteral ? lhs + std::string(rhs.r) : lhs + *rhs.s;
224224}
225225
226226auto operator-(const any& lhs_, const any& rhs_) -> any {
@@ -228,9 +228,9 @@ auto operator-(const any& lhs_, const any& rhs_) -> any {
228228 const any& rhs = any::unthunkVariant(rhs_);
229229 assert(lhs.tag == rhs.tag);
230230 switch (lhs.tag) {
231− case any::tag_t::Integer: return lhs.i - rhs.i;
232− case any::tag_t::Double: return lhs.d - rhs.d;
233− case any::tag_t::Character: return any(char(lhs.c - rhs.c));
231+ case any::Tag::Integer: return lhs.i - rhs.i;
232+ case any::Tag::Double: return lhs.d - rhs.d;
233+ case any::Tag::Character: return any(char(lhs.c - rhs.c));
234234 default: assert(false && "Unsupported tag for '-' operator");
235235 }
236236 return nullptr;
@@ -241,9 +241,9 @@ auto operator*(const any& lhs_, const any& rhs_) -> any {
241241 const any& rhs = any::unthunkVariant(rhs_);
242242 assert(lhs.tag == rhs.tag);
243243 switch (lhs.tag) {
244− case any::tag_t::Integer: return lhs.i * rhs.i;
245− case any::tag_t::Double: return lhs.d * rhs.d;
246− case any::tag_t::Character: return any(char(lhs.c * rhs.c));
244+ case any::Tag::Integer: return lhs.i * rhs.i;
245+ case any::Tag::Double: return lhs.d * rhs.d;
246+ case any::Tag::Character: return any(char(lhs.c * rhs.c));
247247 default: assert(false && "Unsupported tag for '*' operator");
248248 }
249249 return nullptr;
@@ -254,9 +254,9 @@ auto operator/(const any& lhs_, const any& rhs_) -> any {
254254 const any& rhs = any::unthunkVariant(rhs_);
255255 assert(lhs.tag == rhs.tag);
256256 switch (lhs.tag) {
257− case any::tag_t::Integer: return lhs.i / rhs.i;
258− case any::tag_t::Double: return lhs.d / rhs.d;
259− case any::tag_t::Character: return any(char(lhs.c / rhs.c));
257+ case any::Tag::Integer: return lhs.i / rhs.i;
258+ case any::Tag::Double: return lhs.d / rhs.d;
259+ case any::Tag::Character: return any(char(lhs.c / rhs.c));
260260 default: assert(false && "Unsupported tag for '/' operator");
261261 }
262262 return nullptr;
@@ -267,8 +267,8 @@ auto operator%(const any& lhs_, const any& rhs_) -> any {
267267 const any& rhs = any::unthunkVariant(rhs_);
268268 assert(lhs.tag == rhs.tag);
269269 switch (lhs.tag) {
270− case any::tag_t::Integer: return lhs.i % rhs.i;
271− case any::tag_t::Character: return any(char(lhs.c % rhs.c));
270+ case any::Tag::Integer: return lhs.i % rhs.i;
271+ case any::Tag::Character: return any(char(lhs.c % rhs.c));
272272 default: assert(false && "Unsupported tag for '%' operator");
273273 }
274274 return nullptr;
@@ -278,8 +278,8 @@ auto operator%(const any& lhs_, const any& rhs_) -> any {
278278auto operator-(const any& rhs_) -> any {
279279 const any& rhs = any::unthunkVariant(rhs_);
280280 switch (rhs.tag) {
281− case any::tag_t::Integer: return (- rhs.i);
282− case any::tag_t::Double: return (- rhs.d);
281+ case any::Tag::Integer: return (- rhs.i);
282+ case any::Tag::Double: return (- rhs.d);
283283 default: assert(false && "Unsupported tag for unary '-' operator");
284284 }
285285 return nullptr;
pcc/runtime/purescript.hh+83−83
@@ -48,30 +48,30 @@ using std::nullptr_t;
4848using std::runtime_error;
4949
5050namespace Private {
51− struct symbol_generator_anchor_t {};
51+ struct SymbolGeneratorAnchor {};
5252
5353 template <typename T>
54− struct symbol_generator {
55− constexpr static symbol_generator_anchor_t anchor = symbol_generator_anchor_t{};
54+ struct SymbolGenerator {
55+ constexpr static SymbolGeneratorAnchor anchor = SymbolGeneratorAnchor{};
5656 };
5757 template <typename T>
58− constexpr symbol_generator_anchor_t symbol_generator<T>::anchor;
59−}
58+ constexpr SymbolGeneratorAnchor SymbolGenerator<T>::anchor;
6059
61−using symbol_t = const Private::symbol_generator_anchor_t *;
60+ using Symbol = const SymbolGeneratorAnchor *;
61+}
6262
6363#define define_symbol(S) namespace PureScript { \
6464 namespace Private { \
65− namespace Symbol { \
65+ namespace Symbols { \
6666 struct S_ ## S {}; \
6767 } \
6868 } \
6969 }
70−#define symbol(S) (&Private::symbol_generator<::PureScript::Private::Symbol::S_ ## S>::anchor)
70+#define symbol(S) (&Private::SymbolGenerator<::PureScript::Private::Symbols::S_ ## S>::anchor)
7171
7272constexpr bool undefined = false;
7373
74−// Not a real limit, just used for simpler accessors
74+// TODO: Not a real limit, just used for simpler accessors
7575static constexpr size_t unknown_size = 64;
7676
7777// A variant data class designed to provide some features of dynamic typing.
@@ -79,7 +79,7 @@ static constexpr size_t unknown_size = 64;
7979class any {
8080
8181 public:
82− enum class tag_t {
82+ enum class Tag {
8383 Thunk = 0x10,
8484 Integer,
8585 Double,
@@ -99,14 +99,14 @@ class any {
9999 };
100100
101101 private:
102− mutable tag_t tag;
102+ mutable Tag tag;
103103
104104 public:
105105 struct as_thunk {
106106 };
107107 static constexpr as_thunk unthunk = as_thunk{};
108108
109− using map_pair = std::pair<const symbol_t, const any>;
109+ using map_pair = std::pair<const Private::Symbol, const any>;
110110
111111 template <size_t N>
112112 using map = std::array<const map_pair, N>;
@@ -120,33 +120,33 @@ class any {
120120 using thunk = auto (*)(const as_thunk) -> const any&;
121121
122122 private:
123− class closure {
123+ class Closure {
124124 public:
125125 virtual auto operator()(const any&) const -> any = 0;
126− virtual ~closure();
126+ virtual ~Closure();
127127 };
128128
129129 template <typename T>
130− class closure_ : public closure {
130+ class Closure_ : public Closure {
131131 const T lambda;
132132 public:
133− closure_(const T& l) noexcept : lambda(l) {}
133+ Closure_(const T& l) noexcept : lambda(l) {}
134134 auto operator()(const any& arg) const -> any override {
135135 return lambda(arg);
136136 }
137137 };
138138
139− class eff_closure {
139+ class EffClosure {
140140 public:
141141 virtual auto operator()() const -> any = 0;
142− virtual ~eff_closure();
142+ virtual ~EffClosure();
143143 };
144144
145145 template <typename T>
146− class eff_closure_ : public eff_closure {
146+ class EffClosure_ : public EffClosure {
147147 const T lambda;
148148 public:
149− eff_closure_(const T& l) noexcept : lambda(l) {}
149+ EffClosure_(const T& l) noexcept : lambda(l) {}
150150 auto operator()() const -> any override {
151151 return lambda();
152152 }
@@ -165,82 +165,82 @@ class any {
165165 mutable void * u;
166166 mutable managed<std::string> s;
167167 mutable managed<array> a;
168− mutable managed<closure> l;
169− mutable managed<eff_closure> k;
168+ mutable managed<Closure> l;
169+ mutable managed<EffClosure> k;
170170 mutable managed<void> p;
171171 };
172172
173173 public:
174174
175− any(const int val) noexcept : tag(tag_t::Integer), i(val) {}
176− any(const long val) noexcept : tag(tag_t::Integer), i(static_cast<decltype(i)>(val)) {
175+ any(const int val) noexcept : tag(Tag::Integer), i(val) {}
176+ any(const long val) noexcept : tag(Tag::Integer), i(static_cast<decltype(i)>(val)) {
177177 assert(val >= std::numeric_limits<decltype(i)>::min() &&
178178 val <= std::numeric_limits<decltype(i)>::max());
179179 }
180180
181− any(const double val) noexcept : tag(tag_t::Double), d(val) {}
182− any(const char val) noexcept : tag(tag_t::Character), c(val) {}
181+ any(const double val) noexcept : tag(Tag::Double), d(val) {}
182+ any(const char val) noexcept : tag(Tag::Character), c(val) {}
183183
184184 template <typename T, typename = typename std::enable_if<std::is_same<bool,T>::value>::type>
185− any(const T val) noexcept : tag(tag_t::Boolean), b(val) {}
185+ any(const T val) noexcept : tag(Tag::Boolean), b(val) {}
186186
187187 template <size_t N>
188− any(const char (&val)[N]) noexcept : tag(tag_t::StringLiteral), r(val) {}
189− any(char * val) : tag(tag_t::String), s(make_managed<std::string>(val)) {}
188+ any(const char (&val)[N]) noexcept : tag(Tag::StringLiteral), r(val) {}
189+ any(char * val) : tag(Tag::String), s(make_managed<std::string>(val)) {}
190190
191− any(const std::string& val) : tag(tag_t::String), s(make_managed<std::string>(val)) {}
192− any(std::string&& val) noexcept : tag(tag_t::String), s(make_managed<std::string>(std::move(val))) {}
191+ any(const std::string& val) : tag(Tag::String), s(make_managed<std::string>(val)) {}
192+ any(std::string&& val) noexcept : tag(Tag::String), s(make_managed<std::string>(std::move(val))) {}
193193
194− any(const managed<std::string>& val) noexcept : tag(tag_t::String), s(val) {}
195− any(managed<std::string>&& val) noexcept : tag(tag_t::String), s(std::move(val)) {}
194+ any(const managed<std::string>& val) noexcept : tag(Tag::String), s(val) {}
195+ any(managed<std::string>&& val) noexcept : tag(Tag::String), s(std::move(val)) {}
196196
197197 template <size_t N>
198− any(map<N>&& val) noexcept : tag(tag_t::Map), p(make_managed<map<N>>(std::move(val))) {}
198+ any(map<N>&& val) noexcept : tag(Tag::Map), p(make_managed<map<N>>(std::move(val))) {}
199199
200200 template <size_t N>
201− any(data<N>&& val) noexcept : tag(tag_t::Data), p(make_managed<data<N>>(std::move(val))) {}
201+ any(data<N>&& val) noexcept : tag(Tag::Data), p(make_managed<data<N>>(std::move(val))) {}
202202
203− any(const array& val) : tag(tag_t::Array), a(make_managed<array>(val)) {}
204− any(array&& val) noexcept : tag(tag_t::Array), a(make_managed<array>(std::move(val))) {}
203+ any(const array& val) : tag(Tag::Array), a(make_managed<array>(val)) {}
204+ any(array&& val) noexcept : tag(Tag::Array), a(make_managed<array>(std::move(val))) {}
205205
206206 template <typename T>
207207 any(const T& val, typename std::enable_if<std::is_convertible<T,fn>::value>::type* = 0) noexcept
208− : tag(tag_t::Function), f(val) {}
208+ : tag(Tag::Function), f(val) {}
209209
210210 template <typename T, typename = typename std::enable_if<!std::is_same<any,T>::value &&
211211 !std::is_convertible<T,fn>::value>::type>
212212 any(const T& val, typename std::enable_if<std::is_assignable<std::function<any(const any&)>,T>::value>::type* = 0)
213− : tag(tag_t::Closure), l(make_managed<closure_<T>>(val)) {}
213+ : tag(Tag::Closure), l(make_managed<Closure_<T>>(val)) {}
214214
215215 template <typename T>
216216 any(const T& val, typename std::enable_if<std::is_convertible<T,eff_fn>::value>::type* = 0) noexcept
217− : tag(tag_t::EffFunction), e(val) {}
217+ : tag(Tag::EffFunction), e(val) {}
218218
219219 template <typename T,
220220 typename = typename std::enable_if<!std::is_same<any,T>::value &&
221221 !std::is_convertible<T,eff_fn>::value>::type>
222222 any(const T& val, typename std::enable_if<std::is_assignable<std::function<any()>,T>::value>::type* = 0)
223− : tag(tag_t::EffClosure), k(make_managed<eff_closure_<T>>(val)) {}
223+ : tag(Tag::EffClosure), k(make_managed<EffClosure_<T>>(val)) {}
224224
225225 template <typename T>
226226 any(const T& val, typename std::enable_if<std::is_convertible<T,thunk>::value>::type* = 0) noexcept
227− : tag(tag_t::Thunk), t(val) {}
227+ : tag(Tag::Thunk), t(val) {}
228228
229229 template <typename T,
230230 typename = typename std::enable_if<std::is_class<typename std::remove_pointer<T>::type>::value>::type>
231231 any(const T& val, typename std::enable_if<IS_POINTER_TYPE(T)::value>::type* = 0) noexcept
232− : tag(tag_t::Pointer), p(val) {}
232+ : tag(Tag::Pointer), p(val) {}
233233
234234 template <typename T>
235235 any(T&& val, typename std::enable_if<std::is_assignable<managed<void>,T>::value>::type* = 0) noexcept
236− : tag(tag_t::Pointer), p(std::move(val)) {}
236+ : tag(Tag::Pointer), p(std::move(val)) {}
237237
238238 // Explicit void* to raw pointer value
239239 template <typename T>
240240 any(const T& val, typename std::enable_if<std::is_same<T,void*>::value>::type* = 0) noexcept
241− : tag(tag_t::RawPointer), u(val) {}
241+ : tag(Tag::RawPointer), u(val) {}
242242
243− any(nullptr_t) noexcept : tag(tag_t::RawPointer), u(nullptr) {}
243+ any(nullptr_t) noexcept : tag(Tag::RawPointer), u(nullptr) {}
244244
245245
246246#if !defined(USE_GC)
@@ -262,23 +262,23 @@ class any {
262262 template <typename T>
263263 auto assign(T&& other) const noexcept -> void {
264264 switch (other.tag) {
265− case tag_t::Thunk: t = other.t; break;
266− case tag_t::Integer: i = other.i; break;
267− case tag_t::Double: d = other.d; break;
268− case tag_t::Character: c = other.c; break;
269− case tag_t::Boolean: b = other.b; break;
270− case tag_t::StringLiteral: r = other.r; break;
271− case tag_t::Function: f = other.f; break;
272− case tag_t::EffFunction: e = other.e; break;
273− case tag_t::RawPointer: u = other.u; break;
274−
275− case tag_t::String: new (&s) managed<std::string>(move_if_rvalue<T>(other.s)); break;
276− case tag_t::Array: new (&a) managed<array>(move_if_rvalue<T>(other.a)); break;
277− case tag_t::Closure: new (&l) managed<closure>(move_if_rvalue<T>(other.l)); break;
278− case tag_t::EffClosure: new (&k) managed<eff_closure>(move_if_rvalue<T>(other.k)); break;
279− case tag_t::Map:
280− case tag_t::Data:
281− case tag_t::Pointer: new (&p) managed<void>(move_if_rvalue<T>(other.p)); break;
265+ case Tag::Thunk: t = other.t; break;
266+ case Tag::Integer: i = other.i; break;
267+ case Tag::Double: d = other.d; break;
268+ case Tag::Character: c = other.c; break;
269+ case Tag::Boolean: b = other.b; break;
270+ case Tag::StringLiteral: r = other.r; break;
271+ case Tag::Function: f = other.f; break;
272+ case Tag::EffFunction: e = other.e; break;
273+ case Tag::RawPointer: u = other.u; break;
274+
275+ case Tag::String: new (&s) managed<std::string>(move_if_rvalue<T>(other.s)); break;
276+ case Tag::Array: new (&a) managed<array>(move_if_rvalue<T>(other.a)); break;
277+ case Tag::Closure: new (&l) managed<Closure>(move_if_rvalue<T>(other.l)); break;
278+ case Tag::EffClosure: new (&k) managed<EffClosure>(move_if_rvalue<T>(other.k)); break;
279+ case Tag::Map:
280+ case Tag::Data:
281+ case Tag::Pointer: new (&p) managed<void>(move_if_rvalue<T>(other.p)); break;
282282
283283 default: assert(false && "Bad 'any' tag"); break;
284284 }
@@ -286,13 +286,13 @@ class any {
286286
287287 auto destruct() -> void {
288288 switch (tag) {
289− case tag_t::String: s.~managed<std::string>(); break;
290− case tag_t::Array: a.~managed<array>(); break;
291− case tag_t::Closure: l.~managed<closure>(); break;
292− case tag_t::EffClosure: k.~managed<eff_closure>(); break;
293− case tag_t::Map:
294− case tag_t::Data:
295− case tag_t::Pointer: p.~managed<void>(); break;
289+ case Tag::String: s.~managed<std::string>(); break;
290+ case Tag::Array: a.~managed<array>(); break;
291+ case Tag::Closure: l.~managed<Closure>(); break;
292+ case Tag::EffClosure: k.~managed<EffClosure>(); break;
293+ case Tag::Map:
294+ case Tag::Data:
295+ case Tag::Pointer: p.~managed<void>(); break;
296296
297297 default: break;
298298 }
@@ -345,13 +345,13 @@ class any {
345345
346346 auto size() const -> size_t;
347347 auto empty() const -> bool;
348− auto contains(const symbol_t) const -> bool;
348+ auto contains(const Private::Symbol) const -> bool;
349349
350− auto extractPointer(IF_DEBUG(const tag_t)) const -> void*;
350+ auto extractPointer(IF_DEBUG(const Tag)) const -> void*;
351351
352352 auto rawPointer() const -> void* {
353353 const any& variant = unthunkVariant(*this);
354− assert(tag == tag_t::RawPointer);
354+ assert(tag == Tag::RawPointer);
355355 return variant.u;
356356 }
357357
@@ -418,21 +418,21 @@ class any {
418418
419419namespace Private {
420420 template <typename T, typename U=void>
421− struct tag_helper_t {};
421+ struct TagHelper {};
422422
423423 template <size_t N>
424− struct tag_helper_t<any::map<N>> {
425− static constexpr any::tag_t tag = any::tag_t::Map;
424+ struct TagHelper<any::map<N>> {
425+ static constexpr any::Tag tag = any::Tag::Map;
426426 };
427427
428428 template <size_t N>
429− struct tag_helper_t<any::data<N>> {
430− static constexpr any::tag_t tag = any::tag_t::Data;
429+ struct TagHelper<any::data<N>> {
430+ static constexpr any::Tag tag = any::Tag::Data;
431431 };
432432
433433 template <typename T>
434− struct tag_helper_t<T> {
435− static constexpr any::tag_t tag = any::tag_t::Pointer;
434+ struct TagHelper<T> {
435+ static constexpr any::Tag tag = any::Tag::Pointer;
436436 };
437437}
438438
@@ -458,7 +458,7 @@ inline auto cast(const any& a) ->
458458template <typename T, typename = typename std::enable_if<std::is_class<T>::value>::type>
459459inline auto cast(const any& a) ->
460460 typename std::enable_if<!std::is_same<T, any::array>::value, T&>::type {
461− return *static_cast<T*>(a.extractPointer(IF_DEBUG(Private::tag_helper_t<T>::tag)));
461+ return *static_cast<T*>(a.extractPointer(IF_DEBUG(Private::TagHelper<T>::tag)));
462462}
463463
464464template <typename T>
@@ -480,7 +480,7 @@ namespace map {
480480 }
481481
482482 template <size_t N>
483− inline auto get(const symbol_t key, const any::map<N>& a) -> const any& {
483+ inline auto get(const Private::Symbol key, const any::map<N>& a) -> const any& {
484484 static_assert(N > 0, "map size must be greater than zero");
485485 typename std::remove_reference<decltype(a)>::type::size_type i = 0;
486486 do {
@@ -493,7 +493,7 @@ namespace map {
493493 return invalid_key;
494494 }
495495
496− inline auto get(const symbol_t key, const any& a) -> const any& {
496+ inline auto get(const Private::Symbol key, const any& a) -> const any& {
497497 return get(key, cast<any::map<unknown_size>>(a));
498498 }
499499}
src/Language/PureScript/CodeGen/Cpp/Common.hs−1
@@ -204,7 +204,6 @@ nameIsCppReserved name =
204204 , "struct"
205205 , "switch"
206206 , "symbol"
207− , "symbol_t"
208207 , "synchronized"
209208 , "template"
210209 , "the_value"