template<typename... Ts>
struct Enum: std::variant<Ts...> {
  using std::variant<Ts...>::variant;
  template<typename... Fs>
  decltype(auto) match(this auto&& self, Fs&&... fs) {
    struct Visitor: Fs... { using Fs::operator()...; };
    return std::visit(Visitor{ std::forward<Fs>(fs)... }, self);
  }
};

std::string foo(Enum<int, void*, long, double> e) {
  return e.match(
    [] (int i) { return std::format("Got int {}", i); },
    [] (double d) { return std::format("Got double {}", d); },
    [] (auto&&) { return std::string("Got something else"); }
  );
}

int arr[4];
arr[
  [] { return 0; } ()
] = 1;

int arr[1];
[](){return 0;}()[arr] = 1;

switch(i) {
case 0: [
  [fallthrough]
];
case 1:;
}

template <ObjectLike O, ClassLike C, typename... Args>
[[nodiscard]] util::Ptr<O> UnsafeNew(util::Ptr<C> object_class, Args&&... args) {
    if constexpr (std::is_same_v<O, Struct>) {
        auto new_object = util::MakePtr<Struct>(object_class);
        auto it = util::As<StructClass>(object_class)->GetFields().begin();
        (
            [&it, &args, &new_object] {
                auto class_ = *it++;
                if (util::Is<StructClass>(class_)) {
                    new_object->AddFieldValue(
                        UnsafeNew<Struct>(util::As<StructClass>(class_), args));
                } else if (util::Is<StringClass>(class_)) {
                    if constexpr (std::is_convertible_v<decltype(args), std::string_view>) {
                        new_object->AddFieldValue(
                            UnsafeNew<String>(util::As<StringClass>(class_), args));
                    }
                } else {
                    if constexpr (!std::is_convertible_v<std::remove_reference_t<decltype(args)>,
                                                         std::string_view>) {
#define DDB_ADD_PRIMITIVE(P)                                                     \
    else if (util::Is<PrimitiveClass<P>>(class_)) {                              \
        new_object->AddFieldValue(                                               \
            UnsafeNew<Primitive<P>>(util::As<PrimitiveClass<P>>(class_), args)); \
    }

                        if (false) {
                        }
                        DDB_PRIMITIVE_GENERATOR(DDB_ADD_PRIMITIVE)
#undef DDB_ADD_PRIMITIVE
                    }
                }
            }(),
            ...);
        return new_object;
    } else if constexpr (std::is_same_v<O, String>) {
        return util::MakePtr<String>(object_class, std::move(std::get<0>(std::tuple(args...))));
    } else {
        return util::MakePtr<O>(object_class, std::get<0>(std::tuple(args...)));
    }
    throw error::TypeError("Can't create object");
}

return std::make_shared<BrickWall>(BrickWall::WallType::Right, position, scale, rotation);

BrickWall(const WallType wallType, const glm::vec2 &position, const glm::vec2 &scale, const float rotation);

// a
for(auto i = map.begin(); i != map.end(); ++i) {
 map.erase(i);
}

// b
for(auto i = map.begin(); i != map.end(); i++) {
map.erase(i);
}

// c
for(auto i = map.begin(); i != map.end(); ) {
map.erase(++i);
}

// d
for(auto i = map.begin(); i != map.end(); ) {
map.erase(i++);
}