что происходит в std :: function operator () и std :: forward?

Вы правы, что это не ваш типичный сценарий "идеальной пересылки". Краткий пример может помочь проиллюстрировать мотивацию. Предположим, что тип A с инструментальными конструкторами и деструктором:

#include "A.h"
#include <functional>
#include <iostream>

int
main()
{
    A a1{1};
    A a2{2};
    std::function<void(A, A&)> f{[](A x, A& y){}};
    f(a1, a2);
}

Это выведет:

A(int state): 1
A(int state): 2
A(A const& a): 1
A(A&& a): 1
~A(1)
~A(-1)
~A(2)
~A(1)

Объяснение:

a1 и a2 построены в стеке. Затем при передаче в function invoker, a1 сначала копируется для привязки к первому параметру по значению, а затем std::forward<A> вызывается в a1, который перемещает его из параметра по значению в лямбда.

Напротив, a2 не нужно копировать для привязки к параметру function A&, а затем вызывается std::forward<A&>(a2), который пересылает a2 как lvalue вместо rvalue, и это связывается с параметром A& лямбда.

Тогда все рушится. ~A(-1) указывает на уничтожение A в состоянии, созданном с помощью этого инструмента, A.

Таким образом, даже несмотря на то, что ArgTypes не выводится, как в обычной идиоме идеальной пересылки, мы по-прежнему хотим пересылать по значению ArgTypes как rvalue, а по ссылке ArgTypes как lvalues. Итак, std::forward просто делает именно то, что мы хотим здесь.

Думаю, вас здесь многое смущает.

Во-первых, идеальная пересылка не имеет ничего общего с вариативными шаблонами. Вы можете создать класс-оболочку, у которого есть функция, которая принимает один аргумент и пересылает его в завернутый объект:

template<typename T>
struct Wrapper {
    template<typename Arg>
    decltype(auto) test(Arg&& arg) {
        return t.test(std::forward<Arg>(arg));
    }

    T t;
};

Обратите внимание на то, что здесь используется идеальная переадресация без вариативных шаблонов. Если t.test потребует в качестве параметра тип только для перемещения, его невозможно будет вызвать без forward<Arg>(arg).

Второе, что здесь происходит, - это параметр, за которым не следует &&. Добавление && к ArgTypes было бы ошибкой и могло бы привести к сбою компиляции в некоторых случаях. Рассмотрим этот простой случай:

std::function<void(int)> f;
int i = 0;
f(i);

Это не скомпилируется. Если вы добавите && к ArgTypes, все параметры, которые не являются ссылочными (например, int), станут ссылкой на rvalue в операторе вызова (в нашем случае int&&). Поскольку все типы параметров уже правильно определены в списке аргументов std::function, вы хотите получить в операторе вызова именно эти типы, а не преобразованные.

Почему вам нужен std::forward, если вы не используете &&? Потому что, даже если вам не нужно выводить категории значений, вам все равно не нужно копировать все аргументы в содержащуюся функцию. Если один из параметров std::function равен int&, вы не хотите его перемещать. Но если один из параметров std::unique_ptr<int>, вы должны его переместить! И это именно то, для чего нужен std::forward. Перемещается только то, что следует переместить.

std::forward просто добавляет ссылку rvalue к типу, поэтому, принимая во внимание правила сворачивания ссылок, он эффективно передает аргументы ссылки как есть и перемещает аргументы объекта.