Variadic template with function argument

Question

I am trying to develop an ECS registry. How would you improve this ? First disadvantage comes to my mind is using lambdas might be expensive, however I was not able to replicate functionality using F&& template arguments.

    engine->addEntity(1, 
        Position{1, 1},
        Mesh{"thing.gltf"},
        PhysicsBody{10.0f}
    );

    engine->addEntity(2,
        Position{ 2, 2 },
        Mesh{ "other.gltf" },
        PhysicsBody{ 30.0f }
    );

    engine->entity<Position>(1, [&](auto pos) {
        std::cout << "entity";
    });
    engine->each<Position, Mesh>([] (int id, Position& pos, Mesh& mesh) {
        std::cout << "entity" << id;
    });

    template<typename First>
    void entity(int id, std::function<void(First&)> callback)
    {
        auto comp = storage<First>()->get(id);
        if (!comp) return;
        callback(*comp);
    }

    template<typename First, typename...Rest>
    void entity(int id, std::function<void(Rest&...)> callback)
    {
        auto comp = storage<First>()->get(id);
        if (!comp) return;
        entity<Rest...>(id, [](Rest&...args) {
            callback(*comp, args...)
        });
    }

    template<typename T, typename...Rest, typename F>
    void each(F&& callback)
    {
        storage<T>()->forEach([&](int id, T& value) {
            entity<Rest...>(id, [&](Rest&...args) {
                callback(id, value, args...);
            });
        });
    }

Answer 1

using lambdas might be expensive

Why do you think that?

Lambdas are simply syntactic hand waving for class functors (that have been around for over 3 decades). Functors are considered (in general) to be much more efficient than standard functions (especially when used by templates) as the compiler can do a lot of optimizations on them.

auto x = [&capture](X const& parm){ /* BODY */ }

You can consider as syntactic sugar for:

class CompilerNamedType
{
    TypeOfCapure&     capture;
    public:
        CompilerNamedType(TypeOfCapure& capture)
            : capture(capture)
        {}

        CompilerCalculatedReturnType operator()(X const& param) const
        {
            /* BODY */
        }
};

CompilerNamedType  x(capture);

---