Me cuesta entender qué sucede exactamente al pasar una referencia a función a una función como referencia universal (de qué tipo se deduce). Supongamos que tenemos una función foo que toma un parámetro como referencia universal:

template<typename T>
void foo(T&& param)
{
    std::cout << __PRETTY_FUNCTION__ << std::endl;
}

Y luego hagamos lo siguiente:

void(&f)(int) = someFunction;
foo(f);

El resultado será:

void foo(T&&) [with T = void (&)int]

Esto es perfectamente comprensible: estamos pasando el valor l a nuestra función foo, por lo que el tipo deducido es nulo (&) int, y el tipo del parámetro será "nulo (&& &) int", que según las reglas de colapso de referencia se convierte en nulo (& )En t. Param será solo una referencia de valor a una función.

Pero cuando hago lo siguiente:

void(&f)(int) = someFunction;
foo(std::move(f));

foo imprimirá:

void foo(T&&) [with T = void (&)int]

que es exactamente lo mismo que antes! ¿Que está sucediendo aquí? ¿Por qué el resultado es el mismo que al pasar lvalue? Esperaría que, dado que estamos pasando rvalue a foo, el tipo deducido debería ser T = void (int), y param debería convertirse en void (&&) int. Esto siempre sucede con todos los otros tipos "normales" (como clases, tipos primitivos, etc.) ¿Por qué es diferente cuando se trata de referencias de funciones?