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++);
}

int plus(int a, int b);
int minus(int a, int b);

int plus(int a, int b){
    if(a<0 && b>0) return minus(b, -a);
    if(b<0 && a>0) return minus(a, -b);
    if(a<0 && b<0) return -plus(-a, -b);
    if(a==0) return b;
    if(b==0) return a;
    return plus(a-1, b-1)+2;
}
int minus(int a, int b){
    if(a<0 && b>0) return -plus(-a, b);
    if(b<0 && a>0) return plus(a, -b);
    if(a<0 && b<0) return -minus(-a, -b);
    if(a==0) return -b;
    if(b==0) return a;
    return minus(a-1, b-1);
}