std :: función const corrección

Supongamos que tengo un tipo invocable como este:

struct mutable_callable
{
    int my_mutable = 0;
    int operator()() { // Not const
        return my_mutable++;
    }
};

Tenga en cuenta que mutable_callabletiene una no constante operator()que modifica una variable miembro .....

Ahora suponga que creo un std::functionfuera de mi tipo:

std::function<int()> foo = mutable_callable{};

Ahora puedo hacer esto:

void invoke(std::function<int()> const& z)
{
    z();
}

int main()
{
    invoke(foo); // foo changed.....oops
}

Ahora, por lo que puedo decir, std::functions operator()es constsegún: https://en.cppreference.com/w/cpp/utility/functional/function/operator ()

Así que mi intuición es que no deberías poder hacer esto .....

Pero luego mirando: https://en.cppreference.com/w/cpp/utility/functional/function/function

Esto no parece poner ninguna restricción sobre si el tipo invocable tiene o no una constante operator()......

Entonces mi pregunta es la siguiente: estoy en lo cierto al suponer que std::function<int()> const&es esencialmente lo mismo, ya std::function<int()>&que no existe una diferencia real entre el comportamiento de los dos ... y si ese es el caso, ¿por qué no es constcorrecto?

Esto se reduce a lo mismo que struct A { int* x; };, donde const A a;puede modificar el valor de *(a.x)(pero no a dónde apunta). Hay un nivel de indirección en std::function(desde el tipo de borrado) a través del cual constno se propaga.

Y no, std::function<int()> const& fno tiene sentido. En un std::function<int()>& f, podría asignar un functor diferente f, lo que no puede hacer en el constcaso.