aba280f · rowtype-yoga/purescript-native

git.iko.soy/rowtype-yoga/purescript-native

C++: minor renaming in runtime

commitaba280f94e53705d08f1918b0b8fd86cab830f92 authorAndy Arvanitis <andyarvanitis@gmail.com> dateMon 31 Oct 2016, 20:47 (10 years ago) parent19efe37

2 files changed+142−142

compare with golang

unifiedsplit

pcc/include/purescript.cc+79−79 pcc/include/purescript.hh+63−63

pcc/include/purescript.cc+79−79

@@ -17,70 +17,70 @@

1717

1818namespace PureScript {

1919

20−#define RETURN_VALUE(TYPE, ACCESSOR, INDIRECTION) \

20+#define RETURN_VALUE(TAG, ACCESSOR, INDIRECTION) \

2121 const any& variant = unthunkVariant(*this); \

22− assert(variant.type == TYPE); \

22+ assert(variant.tag == TAG); \

2323 return INDIRECTION(variant.ACCESSOR); \

2424

2525auto any::operator()(const any& arg) const -> any {

2626 const any& variant = unthunkVariant(*this);

27− if (variant.type == Type::Closure) {

27+ if (variant.tag == tag_t::Closure) {

2828 return (*variant.l)(arg);

2929 }

30− assert(variant.type == Type::Function);

30+ assert(variant.tag == tag_t::Function);

3131 return (*variant.f)(arg);

3232}

3333

3434auto any::operator()(const as_thunk) const -> const any& {

35− assert(type == Type::Thunk);

35+ assert(tag == tag_t::Thunk);

3636 return (*t)(unthunk);

3737}

3838

3939auto any::operator()() const -> any {

4040 const any& variant = unthunkVariant(*this);

41− if (variant.type == Type::EffClosure) {

41+ if (variant.tag == tag_t::EffClosure) {

4242 return (*variant.k)();

4343 }

44− assert(variant.type == Type::EffFunction);

44+ assert(variant.tag == tag_t::EffFunction);

4545 return (*variant.e)();

4646}

4747

4848any::operator int() const {

49− RETURN_VALUE(Type::Integer, i,)

49+ RETURN_VALUE(tag_t::Integer, i,)

5050}

5151

5252any::operator double() const {

53− RETURN_VALUE(Type::Double, d,)

53+ RETURN_VALUE(tag_t::Double, d,)

5454}

5555

5656any::operator bool() const {

57− RETURN_VALUE(Type::Boolean, b,)

57+ RETURN_VALUE(tag_t::Boolean, b,)

5858}

5959

6060any::operator char() const {

61− RETURN_VALUE(Type::Character, c,)

61+ RETURN_VALUE(tag_t::Character, c,)

6262}

6363

6464any::operator cstring() const {

6565 const any& variant = unthunkVariant(*this);

66− if (variant.type == Type::StringLiteral) {

66+ if (variant.tag == tag_t::StringLiteral) {

6767 return variant.r;

6868 }

69− assert(variant.type == Type::String);

69+ assert(variant.tag == tag_t::String);

7070 return variant.s->c_str();

7171}

7272

7373any::operator const array&() const {

74− RETURN_VALUE(Type::Array, a, *)

74+ RETURN_VALUE(tag_t::Array, a, *)

7575}

7676

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* {

7878 RETURN_VALUE(t, POINTER_FROM_MEMBER(p),)

7979}

8080

8181auto any::unthunkVariant(const any& a) -> const any& {

8282 const any * variant = &a;

83− while (variant->type == Type::Thunk) {

83+ while (variant->tag == tag_t::Thunk) {

8484 variant = &((*variant->t)(unthunk));

8585 }

8686 return *variant;

@@ -130,16 +130,16 @@ auto any::contains(const symbol_t key) const -> bool {

130130#define DEFINE_CSTR_EQUALS_OPERATOR() \

131131 auto operator==(const any& lhs_, const char * rhs) -> bool { \

132132 const any& lhs = any::unthunkVariant(lhs_); \

133− assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \

134− if (lhs.type == any::Type::StringLiteral) { \

133+ assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String); \

134+ if (lhs.tag == any::tag_t::StringLiteral) { \

135135 return (lhs.r == rhs) || (strcmp(lhs.r, rhs) == 0); \

136136 } \

137137 return strcmp(lhs.s->c_str(), rhs) == 0; \

138138 } \

139139 auto operator==(const char * lhs, const any& rhs_) -> bool { \

140140 const any& rhs = any::unthunkVariant(rhs_); \

141− assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \

142− if (rhs.type == any::Type::StringLiteral) { \

141+ assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String); \

142+ if (rhs.tag == any::tag_t::StringLiteral) { \

143143 return (lhs == rhs.r) || (strcmp(lhs, rhs) == 0); \

144144 } \

145145 return strcmp(lhs, rhs.s->c_str()) == 0; \

@@ -157,21 +157,21 @@ auto any::contains(const symbol_t key) const -> bool {

157157 auto operator op (const any& lhs_, const any& rhs_) -> bool { \

158158 const any& lhs = any::unthunkVariant(lhs_); \

159159 const any& rhs = any::unthunkVariant(rhs_); \

160− switch (lhs.type) { \

161− case any::Type::Integer: assert(lhs.type == any::Type::Integer); return lhs.i op rhs.i; \

162− case any::Type::Double: assert(lhs.type == any::Type::Double); return lhs.d op rhs.d; \

163− case any::Type::Character: assert(lhs.type == any::Type::Character); return lhs.c op rhs.c; \

164− case any::Type::Boolean: assert(lhs.type == any::Type::Boolean); return lhs.b op rhs.b; \

165− case any::Type::StringLiteral: \

166− assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \

167− assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \

168− return strcmp(lhs.r, rhs.type == any::Type::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \

169− case any::Type::String: \

170− assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String); \

171− assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String); \

172− return strcmp(lhs.s->c_str(), rhs.type == any::Type::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \

173− case any::Type::Pointer: return lhs.p op rhs.p; \

174− default: assert(false && "Unsupported type for operator " #op); \

160+ switch (lhs.tag) { \

161+ case any::tag_t::Integer: assert(lhs.tag == any::tag_t::Integer); return lhs.i op rhs.i; \

162+ case any::tag_t::Double: assert(lhs.tag == any::tag_t::Double); return lhs.d op rhs.d; \

163+ case any::tag_t::Character: assert(lhs.tag == any::tag_t::Character); return lhs.c op rhs.c; \

164+ case any::tag_t::Boolean: assert(lhs.tag == any::tag_t::Boolean); return lhs.b op rhs.b; \

165+ case any::tag_t::StringLiteral: \

166+ assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String); \

167+ assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String); \

168+ return strcmp(lhs.r, rhs.tag == any::tag_t::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \

169+ case any::tag_t::String: \

170+ assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String); \

171+ assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String); \

172+ return strcmp(lhs.s->c_str(), rhs.tag == any::tag_t::StringLiteral ? rhs.r : rhs.s->c_str()) op 0; \

173+ case any::tag_t::Pointer: return lhs.p op rhs.p; \

174+ default: assert(false && "Unsupported tag for operator " #op); \

175175 } \

176176 return false; \

177177 }

@@ -197,44 +197,44 @@ DEFINE_CSTR_COMPARISON_OPERATOR(>=)

197197auto operator+(const any& lhs_, const any& rhs_) -> any {

198198 const any& lhs = any::unthunkVariant(lhs_);

199199 const any& rhs = any::unthunkVariant(rhs_);

200− switch (lhs.type) {

201− case any::Type::Integer: assert(lhs.type == any::Type::Integer); return lhs.i + rhs.i;

202− case any::Type::Double: assert(lhs.type == any::Type::Double); return lhs.d + rhs.d;

203− case any::Type::Character: assert(lhs.type == any::Type::Character); return any(char(lhs.c + rhs.c));

204− case any::Type::StringLiteral:

205− assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);

206− assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);

207− return rhs.type == any::Type::StringLiteral ? std::string(lhs.r) + rhs.r : lhs.r + *rhs.s;

208− case any::Type::String:

209− assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);

210− assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);

211− return rhs.type == any::Type::StringLiteral ? *lhs.s + rhs.r : *lhs.s + *rhs.s;

212− default: assert(false && "Unsupported type for '+' operator");

200+ switch (lhs.tag) {

201+ case any::tag_t::Integer: assert(lhs.tag == any::tag_t::Integer); return lhs.i + rhs.i;

202+ case any::tag_t::Double: assert(lhs.tag == any::tag_t::Double); return lhs.d + rhs.d;

203+ case any::tag_t::Character: assert(lhs.tag == any::tag_t::Character); return any(char(lhs.c + rhs.c));

204+ case any::tag_t::StringLiteral:

205+ assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String);

206+ assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String);

207+ return rhs.tag == any::tag_t::StringLiteral ? std::string(lhs.r) + rhs.r : lhs.r + *rhs.s;

208+ case any::tag_t::String:

209+ assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String);

210+ assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String);

211+ return rhs.tag == any::tag_t::StringLiteral ? *lhs.s + rhs.r : *lhs.s + *rhs.s;

212+ default: assert(false && "Unsupported tag for '+' operator");

213213 }

214214 return nullptr;

215215}

216216

217217auto operator+(const any& lhs_, const char * rhs) -> std::string {

218218 const any& lhs = any::unthunkVariant(lhs_);

219− assert(lhs.type == any::Type::StringLiteral || lhs.type == any::Type::String);

220− return lhs.type == any::Type::StringLiteral ? std::string(lhs.r) + rhs : *lhs.s + rhs;

219+ assert(lhs.tag == any::tag_t::StringLiteral || lhs.tag == any::tag_t::String);

220+ return lhs.tag == any::tag_t::StringLiteral ? std::string(lhs.r) + rhs : *lhs.s + rhs;

221221}

222222

223223auto operator+(const char * lhs, const any& rhs_) -> std::string {

224224 const any& rhs = any::unthunkVariant(rhs_);

225− assert(rhs.type == any::Type::StringLiteral || rhs.type == any::Type::String);

226− return rhs.type == any::Type::StringLiteral ? lhs + std::string(rhs.r) : lhs + *rhs.s;

225+ assert(rhs.tag == any::tag_t::StringLiteral || rhs.tag == any::tag_t::String);

226+ return rhs.tag == any::tag_t::StringLiteral ? lhs + std::string(rhs.r) : lhs + *rhs.s;

227227}

228228

229229auto operator-(const any& lhs_, const any& rhs_) -> any {

230230 const any& lhs = any::unthunkVariant(lhs_);

231231 const any& rhs = any::unthunkVariant(rhs_);

232− assert(lhs.type == rhs.type);

233− switch (lhs.type) {

234− case any::Type::Integer: return lhs.i - rhs.i;

235− case any::Type::Double: return lhs.d - rhs.d;

236− case any::Type::Character: return any(char(lhs.c - rhs.c));

237− default: assert(false && "Unsupported type for '-' operator");

232+ assert(lhs.tag == rhs.tag);

233+ switch (lhs.tag) {

234+ case any::tag_t::Integer: return lhs.i - rhs.i;

235+ case any::tag_t::Double: return lhs.d - rhs.d;

236+ case any::tag_t::Character: return any(char(lhs.c - rhs.c));

237+ default: assert(false && "Unsupported tag for '-' operator");

238238 }

239239 return nullptr;

240240}

@@ -242,12 +242,12 @@ auto operator-(const any& lhs_, const any& rhs_) -> any {

242242auto operator*(const any& lhs_, const any& rhs_) -> any {

243243 const any& lhs = any::unthunkVariant(lhs_);

244244 const any& rhs = any::unthunkVariant(rhs_);

245− assert(lhs.type == rhs.type);

246− switch (lhs.type) {

247− case any::Type::Integer: return lhs.i * rhs.i;

248− case any::Type::Double: return lhs.d * rhs.d;

249− case any::Type::Character: return any(char(lhs.c * rhs.c));

250− default: assert(false && "Unsupported type for '*' operator");

245+ assert(lhs.tag == rhs.tag);

246+ switch (lhs.tag) {

247+ case any::tag_t::Integer: return lhs.i * rhs.i;

248+ case any::tag_t::Double: return lhs.d * rhs.d;

249+ case any::tag_t::Character: return any(char(lhs.c * rhs.c));

250+ default: assert(false && "Unsupported tag for '*' operator");

251251 }

252252 return nullptr;

253253}

@@ -255,12 +255,12 @@ auto operator*(const any& lhs_, const any& rhs_) -> any {

255255auto operator/(const any& lhs_, const any& rhs_) -> any {

256256 const any& lhs = any::unthunkVariant(lhs_);

257257 const any& rhs = any::unthunkVariant(rhs_);

258− assert(lhs.type == rhs.type);

259− switch (lhs.type) {

260− case any::Type::Integer: return lhs.i / rhs.i;

261− case any::Type::Double: return lhs.d / rhs.d;

262− case any::Type::Character: return any(char(lhs.c / rhs.c));

263− default: assert(false && "Unsupported type for '/' operator");

258+ assert(lhs.tag == rhs.tag);

259+ switch (lhs.tag) {

260+ case any::tag_t::Integer: return lhs.i / rhs.i;

261+ case any::tag_t::Double: return lhs.d / rhs.d;

262+ case any::tag_t::Character: return any(char(lhs.c / rhs.c));

263+ default: assert(false && "Unsupported tag for '/' operator");

264264 }

265265 return nullptr;

266266}

@@ -268,11 +268,11 @@ auto operator/(const any& lhs_, const any& rhs_) -> any {

268268auto operator%(const any& lhs_, const any& rhs_) -> any {

269269 const any& lhs = any::unthunkVariant(lhs_);

270270 const any& rhs = any::unthunkVariant(rhs_);

271− assert(lhs.type == rhs.type);

272− switch (lhs.type) {

273− case any::Type::Integer: return lhs.i % rhs.i;

274− case any::Type::Character: return any(char(lhs.c % rhs.c));

275− default: assert(false && "Unsupported type for '%' operator");

271+ assert(lhs.tag == rhs.tag);

272+ switch (lhs.tag) {

273+ case any::tag_t::Integer: return lhs.i % rhs.i;

274+ case any::tag_t::Character: return any(char(lhs.c % rhs.c));

275+ default: assert(false && "Unsupported tag for '%' operator");

276276 }

277277 return nullptr;

278278}

@@ -280,10 +280,10 @@ auto operator%(const any& lhs_, const any& rhs_) -> any {

280280// unary negate

281281auto operator-(const any& rhs_) -> any {

282282 const any& rhs = any::unthunkVariant(rhs_);

283− switch (rhs.type) {

284− case any::Type::Integer: return (- rhs.i);

285− case any::Type::Double: return (- rhs.d);

286− default: assert(false && "Unsupported type for unary '-' operator");

283+ switch (rhs.tag) {

284+ case any::tag_t::Integer: return (- rhs.i);

285+ case any::tag_t::Double: return (- rhs.d);

286+ default: assert(false && "Unsupported tag for unary '-' operator");

287287 }

288288 return nullptr;

289289}

pcc/include/purescript.hh+63−63

@@ -71,7 +71,7 @@ static constexpr size_t unknown_size = 64;

7171class any {

7272

7373 public:

74− enum class Type {

74+ enum class tag_t {

7575 Thunk = 0x10,

7676 Integer,

7777 Double,

@@ -91,7 +91,7 @@ class any {

9191 };

9292

9393 private:

94− mutable Type type;

94+ mutable tag_t tag;

9595

9696 public:

9797 struct as_thunk {

@@ -164,74 +164,74 @@ class any {

164164

165165 public:

166166

167− any(const int val) noexcept : type(Type::Integer), i(val) {}

168− any(const long int_value) noexcept : type(Type::Integer), i(int_value) {

167+ any(const int val) noexcept : tag(tag_t::Integer), i(val) {}

168+ any(const long int_value) noexcept : tag(tag_t::Integer), i(int_value) {

169169 assert(int_value >= INT_MIN && int_value <= INT_MAX);

170170 }

171171

172− any(const double val) noexcept : type(Type::Double), d(val) {}

173− any(const char val) noexcept : type(Type::Character), c(val) {}

172+ any(const double val) noexcept : tag(tag_t::Double), d(val) {}

173+ any(const char val) noexcept : tag(tag_t::Character), c(val) {}

174174

175175 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) {}

177177

178178 template <size_t N>

179− any(const char (&val)[N]) noexcept : type(Type::StringLiteral), r(val) {}

180− any(char * val) : type(Type::String), s(make_managed<std::string>(val)) {}

179+ any(const char (&val)[N]) noexcept : tag(tag_t::StringLiteral), r(val) {}

180+ any(char * val) : tag(tag_t::String), s(make_managed<std::string>(val)) {}

181181

182− any(const std::string& val) : type(Type::String), s(make_managed<std::string>(val)) {}

183− any(std::string&& val) noexcept : type(Type::String), s(make_managed<std::string>(std::move(val))) {}

182+ any(const std::string& val) : tag(tag_t::String), s(make_managed<std::string>(val)) {}

183+ any(std::string&& val) noexcept : tag(tag_t::String), s(make_managed<std::string>(std::move(val))) {}

184184

185− any(const managed<std::string>& val) noexcept : type(Type::String), s(val) {}

186− any(managed<std::string>&& val) noexcept : type(Type::String), s(std::move(val)) {}

185+ any(const managed<std::string>& val) noexcept : tag(tag_t::String), s(val) {}

186+ any(managed<std::string>&& val) noexcept : tag(tag_t::String), s(std::move(val)) {}

187187

188188 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))) {}

190190

191191 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))) {}

193193

194− any(const array& val) : type(Type::Array), a(make_managed<array>(val)) {}

195− any(array&& val) noexcept : type(Type::Array), a(make_managed<array>(std::move(val))) {}

194+ any(const array& val) : tag(tag_t::Array), a(make_managed<array>(val)) {}

195+ any(array&& val) noexcept : tag(tag_t::Array), a(make_managed<array>(std::move(val))) {}

196196

197197 template <typename T>

198198 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) {}

200200

201201 template <typename T, typename = typename std::enable_if<!std::is_same<any,T>::value &&

202202 !std::is_convertible<T,fn>::value>::type>

203203 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)) {}

205205

206206 template <typename T>

207207 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) {}

209209

210210 template <typename T,

211211 typename = typename std::enable_if<!std::is_same<any,T>::value &&

212212 !std::is_convertible<T,eff_fn>::value>::type>

213213 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)) {}

215215

216216 template <typename T>

217217 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) {}

219219

220220 template <typename T,

221221 typename = typename std::enable_if<std::is_class<typename std::remove_pointer<T>::type>::value>::type>

222222 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) {}

224224

225225 template <typename T>

226226 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)) {}

228228

229229 // Explicit void* to raw pointer value

230230 template <typename T>

231231 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) {}

233233

234− any(nullptr_t) noexcept : type(Type::RawPointer), u(nullptr) {}

234+ any(nullptr_t) noexcept : tag(tag_t::RawPointer), u(nullptr) {}

235235

236236

237237#if !defined(USE_GC)

@@ -252,62 +252,62 @@ class any {

252252

253253 template <typename T>

254254 auto assign(T&& other) const noexcept -> void {

255− switch (other.type) {

256− case Type::Thunk: t = other.t; break;

257− case Type::Integer: i = other.i; break;

258− case Type::Double: d = other.d; break;

259− case Type::Character: c = other.c; break;

260− case Type::Boolean: b = other.b; break;

261− case Type::StringLiteral: r = other.r; break;

262− case Type::Function: f = other.f; break;

263− case Type::EffFunction: e = other.e; break;

264− case Type::RawPointer: u = other.u; break;

265−

266− case Type::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;

268− case Type::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;

270− case Type::Map:

271− case Type::Data:

272− case Type::Pointer: new (&p) managed<void>(move_if_rvalue<T>(other.p)); break;

273−

274− default: assert(false && "Bad 'any' type"); break;

255+ switch (other.tag) {

256+ case tag_t::Thunk: t = other.t; break;

257+ case tag_t::Integer: i = other.i; break;

258+ case tag_t::Double: d = other.d; break;

259+ case tag_t::Character: c = other.c; break;

260+ case tag_t::Boolean: b = other.b; break;

261+ case tag_t::StringLiteral: r = other.r; break;

262+ case tag_t::Function: f = other.f; break;

263+ case tag_t::EffFunction: e = other.e; break;

264+ case tag_t::RawPointer: u = other.u; break;

265+

266+ case tag_t::String: new (&s) managed<std::string>(move_if_rvalue<T>(other.s)); break;

267+ case tag_t::Array: new (&a) managed<array>(move_if_rvalue<T>(other.a)); break;

268+ case tag_t::Closure: new (&l) managed<closure>(move_if_rvalue<T>(other.l)); break;

269+ case tag_t::EffClosure: new (&k) managed<eff_closure>(move_if_rvalue<T>(other.k)); break;

270+ case tag_t::Map:

271+ case tag_t::Data:

272+ case tag_t::Pointer: new (&p) managed<void>(move_if_rvalue<T>(other.p)); break;

273+

274+ default: assert(false && "Bad 'any' tag"); break;

275275 }

276276 }

277277

278278 auto destruct() -> void {

279− switch (type) {

280− case Type::String: s.~managed<std::string>(); break;

281− case Type::Array: a.~managed<array>(); break;

282− case Type::Closure: l.~managed<closure>(); break;

283− case Type::EffClosure: k.~managed<eff_closure>(); break;

284− case Type::Map:

285− case Type::Data:

286− case Type::Pointer: p.~managed<void>(); break;

279+ switch (tag) {

280+ case tag_t::String: s.~managed<std::string>(); break;

281+ case tag_t::Array: a.~managed<array>(); break;

282+ case tag_t::Closure: l.~managed<closure>(); break;

283+ case tag_t::EffClosure: k.~managed<eff_closure>(); break;

284+ case tag_t::Map:

285+ case tag_t::Data:

286+ case tag_t::Pointer: p.~managed<void>(); break;

287287

288288 default: break;

289289 }

290290 }

291291

292292 public:

293− any(const any& other) noexcept : type(other.type) {

293+ any(const any& other) noexcept : tag(other.tag) {

294294 assign(other);

295295 }

296296

297− any(any&& other) noexcept : type(other.type) {

297+ any(any&& other) noexcept : tag(other.tag) {

298298 assign(std::move(other));

299299 }

300300

301301 auto operator=(const any& rhs) noexcept -> any& {

302302 destruct();

303− type = rhs.type;

303+ tag = rhs.tag;

304304 assign(rhs);

305305 return *this;

306306 }

307307

308308 auto operator=(any&& rhs) noexcept -> any& {

309309 destruct();

310− type = rhs.type;

310+ tag = rhs.tag;

311311 assign(std::move(rhs));

312312 return *this;

313313 }

@@ -337,11 +337,11 @@ class any {

337337

338338 auto contains(const symbol_t) const -> bool;

339339

340− auto extractPointer(IF_DEBUG(const Type)) const -> void*;

340+ auto extractPointer(IF_DEBUG(const tag_t)) const -> void*;

341341

342342 auto rawPointer() const -> void* {

343343 const any& variant = unthunkVariant(*this);

344− assert(type == Type::RawPointer);

344+ assert(tag == tag_t::RawPointer);

345345 return variant.u;

346346 }

347347

@@ -411,17 +411,17 @@ struct tag_helper {};

411411

412412template <size_t N>

413413struct 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;

415415};

416416

417417template <size_t N>

418418struct 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;

420420};

421421

422422template <typename T>

423423struct tag_helper<T> {

424− static constexpr any::Type tag = any::Type::Pointer;

424+ static constexpr any::tag_t tag = any::tag_t::Pointer;

425425};

426426

427427template <typename T>