template<class L> Subscribe(L lambda)
{
    std::function<сигнатура вызова lambdы> f; // типа void(int, int)
    std::function<void(сигнатура параметров lambdы)> f; // типа только "int, int"
}

Subscribe([](int, int){});

B>template<class L> Subscribe(L lambda)
B>{
B>    std::function<сигнатура вызова lambdы> f; // типа void(int, int)
B>    std::function<void(сигнатура параметров lambdы)> f; // типа только "int, int"
B>}

B>Subscribe([](int, int){});
B>

namespace fn {

/**
 * \Note Function details description
 */
template<typename Sign, typename R, typename... Args>
struct traits_base {
  using signature = Sign;
  using is_method = std::is_member_function_pointer<signature>;
  using args = std::tuple<Args...>;
  using arity = std::integral_constant<unsigned, sizeof...(Args)>;
  using result = R;
};

/**
 * \Note Function details specializations
 */
template<typename T>
struct traits : traits<decltype(&T::operator())> {};
template<typename R, typename... Args>
struct traits<R(*)(Args...)> : traits_base<R(*)(Args...), R, Args...> {};
template<typename R, typename... Args>
struct traits<R(* const)(Args...)> : traits_base<R(* const)(Args...), R, Args...> {};
#if __cplusplus >= 201703
template<typename R, typename... Args>
struct traits<R(*)(Args...) noexcept> : traits_base<R(*)(Args...), R, Args...> {};
template<typename R, typename... Args>
struct traits<R(* const)(Args...) noexcept> : traits_base<R(* const)(Args...), R, Args...> {};
#endif // __cplusplus >= 201703
template<typename R, typename C, typename... Args>
struct traits<R(C::*)(Args...)> : traits_base<R(C::*)(Args...), R, Args...> {};
template<typename R, typename C, typename... Args>
struct traits<R(C::* const)(Args...)> : traits_base<R(C::* const)(Args...), R, Args...> {};
template<typename R, typename C, typename... Args>
struct traits<R(C::*)(Args...) const> : traits_base<R(C::*)(Args...) const, R, Args...> {};
template<typename R, typename C, typename... Args>
struct traits<R(C::* const)(Args...) const> : traits_base<R(C::* const)(Args...) const, R, Args...> {};
#if __cplusplus >= 201703
template<typename R, typename C, typename... Args>
struct traits<R(C::*)(Args...) noexcept> : traits_base<R(C::*)(Args...), R, Args...> {};
template<typename R, typename C, typename... Args>
struct traits<R(C::* const)(Args...) noexcept> : traits_base<R(C::* const)(Args...), R, Args...> {};
template<typename R, typename C, typename... Args>
struct traits<R(C::*)(Args...) const noexcept> : traits_base<R(C::*)(Args...) const, R, Args...> {};
template<typename R, typename C, typename... Args>
struct traits<R(C::* const)(Args...) const noexcept> : traits_base<R(C::* const)(Args...) const, R, Args...> {};
#endif // __cplusplus >= 201703

} // namespace fn

// use, e.g. std::function<typename fn::traits<L>::signature> f;

    template<class ...A> struct CActiveDelegate
    {
        CDelegate<void(A...)>        Function;
        std::function<void(A...)>    Lambda;
        EListen                Listen;

        CActiveDelegate()
        {
        }
    };

    template<class X, class Y, typename...A> CActiveDelegate<A...> CreateActiveDelegate(Y* x, void (X::*func)(A...), EListen l)
    { 
        CActiveDelegate<A...> d;
        d.Function = fastdelegate<void(A...)>(x, func);
        d.Listen = l;
        return d;
    }


    template<class ...L> CActiveDelegate<typename fn::traits<L>::args> CreateLambdaDelegate(L la, EListen l)
    { 
        CActiveDelegate<typename fn::traits<L>::args> d;
        d.Lambda = la;
        d.Listen = l;
        return d;
    }

    #define FunctionSubscriber(method, l)    CreateActiveDelegate(this, &std::remove_pointer<decltype(this)>::type::method, l)
    #define LambdaSubscriber(la, l)        CreateLambdaDelegate(la, l)

    template<class ...A> class CActiveEvent
    {
        public:
            void operator += (CActiveDelegate<A...> & d)
            {
                Subscribers.push_back(d);
            }

        protected:
            CArray<CActiveDelegate<A...>>    Subscribers;
    };


    class A
    {
        void AAA(CString &)
        {
            CActiveEvent<CString &> aaa;

            aaa += FunctionSubscriber(AAA, EListen::NormalAll);
            aaa += LambdaSubscriber([](CString &){}, EListen::NormalAll);

        }
    };

B>    template<class ...L> CActiveDelegate<typename fn::traits<L>::args> CreateLambdaDelegate(L la, EListen l)
B>    { 
B>        CActiveDelegate<typename fn::traits<L>::args> d;
B>        d.Lambda = la;
B>        d.Listen = l;
B>        return d;
B>    }
B>

template<class L> auto CreateLambdaDelegate(L la, EListen l) -> CActiveDelegate<typename fn::traits<L>::signature> {...}

    template<typename S> struct CActiveDelegate
    {
        fastdelegate::FastDelegate<S>    Function;
        std::function<S>        Lambda;
        int                Listen;

        CActiveDelegate()
        {
        }
    };

    template<class X, class Y, typename...A> auto CreateActiveDelegate(Y* x, void (X::*func)(A...), int l)
    { 
        CActiveDelegate<void(A...)> d;
        d.Function = fastdelegate::FastDelegate<void(A...)>(x, func);
        d.Listen = l;
        return d;
    }


    template<class L> auto CreateLambdaDelegate(L la, int l)
    { 
        CActiveDelegate<typename fn::traits<L>::signature> d;
        d.Lambda = la;
        d.Listen = l;
        return d;
    }

    #define FunctionSubscriber(method, l)    CreateActiveDelegate(this, &std::remove_pointer<decltype(this)>::type::method, l)
    #define LambdaSubscriber(la, l)            CreateLambdaDelegate(la, l)

    template<class ...A> class CActiveEvent
    {
        public:
            void operator += (CActiveDelegate<void(A...)> & d)
            {
                Subscribers.push_back(d);
            }

        protected:
            std::list<CActiveDelegate<void(A...)>>    Subscribers;
    };


    class A
    {
        void AAA(std::string &)
        {
            CActiveEvent<std::string &> aaa;

            aaa += FunctionSubscriber(AAA, 1);
            aaa += LambdaSubscriber([](std::string &){}, 2);

        }
    };

B>    template<typename S> struct CActiveDelegate
B>    {
B>        fastdelegate::FastDelegate<S>    Function;
B>        std::function<S>        Lambda;
B>        int                Listen;

B>        CActiveDelegate()
B>        {
B>        }
B>    };

B>    template<class X, class Y, typename...A> auto CreateActiveDelegate(Y* x, void (X::*func)(A...), int l)
B>    { 
B>        CActiveDelegate<void(A...)> d;
B>        d.Function = fastdelegate::FastDelegate<void(A...)>(x, func);
B>        d.Listen = l;
B>        return d;
B>    }


B>    template<class L> auto CreateLambdaDelegate(L la, int l)
B>    { 
B>        CActiveDelegate<typename fn::traits<L>::signature> d;
B>        d.Lambda = la;
B>        d.Listen = l;
B>        return d;
B>    }

B>    #define FunctionSubscriber(method, l)    CreateActiveDelegate(this, &std::remove_pointer<decltype(this)>::type::method, l)
B>    #define LambdaSubscriber(la, l)            CreateLambdaDelegate(la, l)

B>    template<class ...A> class CActiveEvent
B>    {
B>        public:
B>            void operator += (CActiveDelegate<void(A...)> & d)
B>            {
B>                Subscribers.push_back(d);
B>            }

B>        protected:
B>            std::list<CActiveDelegate<void(A...)>>    Subscribers;
B>    };


B>    class A
B>    {
B>        void AAA(std::string &)
B>        {
B>            CActiveEvent<std::string &> aaa;

B>            aaa += FunctionSubscriber(AAA, 1);
B>            aaa += LambdaSubscriber([](std::string &){}, 2);

B>        }
B>    };
B>

aaa += FunctionSubscriber(AAA, 1);

aaa += FunctionSubscriber(AAA, 1);

aaa += FunctionSubscriber(AAA, 1);

B>template<class L> Subscribe(L lambda)
B>{
B>    std::function<сигнатура вызова lambdы> f; // типа void(int, int)
B>    std::function<void(сигнатура параметров lambdы)> f; // типа только "int, int"
B>}

B>Subscribe([](int, int){});
B>

#include <string>
#include <tuple>
#include <type_traits>

template <typename>
struct CallableTraits;

template <typename ReturnT, typename...ParamT>
struct CallableTraits<ReturnT(ParamT...)>
{
    static constexpr size_t Arity = sizeof...(ParamT);
    using Signature = ReturnT(ParamT...);
    using ReturnType = ReturnT;
    using ParameterTypes = std::tuple<ParamT...>;
};

template <typename ReturnT, typename...ParamT>
struct CallableTraits<ReturnT(*)(ParamT...)> : CallableTraits<ReturnT(ParamT...)> {};

template <typename T, typename ReturnT, typename...ParamT>
struct CallableTraits<ReturnT(T::*)(ParamT...)> : CallableTraits<ReturnT(ParamT...)> {};

template <typename T, typename ReturnT, typename...ParamT>
struct CallableTraits<ReturnT(T::*)(ParamT...) const> : CallableTraits<ReturnT(ParamT...)> {};

template <typename T>
struct CallableTraits : CallableTraits<decltype(&std::decay_t<T>::operator())> {};

template <typename T>
constexpr size_t CallableArity = CallableTraits<T>::Arity;

template <typename T>
using CallableSignature = typename CallableTraits<T>::Signature;

template <typename T>
using CallableReturnType = typename CallableTraits<T>::ReturnType;

template <typename T, size_t I>
using CallableParameterType = std::tuple_element_t<I, typename CallableTraits<T>::ParameterTypes>;

int main()
{
    int i = 42;

    auto lambda = [=](int, double, const std::string&) { return i; };

    using L = decltype(lambda);

    static_assert(CallableArity<L> == 3, "");
    static_assert(std::is_same_v<CallableSignature<L>, int(int, double, const std::string&)>, "");
    static_assert(std::is_same_v<CallableParameterType<L, 0>, int>, "");
    static_assert(std::is_same_v<CallableParameterType<L, 1>, double>, "");
    static_assert(std::is_same_v<CallableParameterType<L, 2>, const std::string&>, "");
    static_assert(std::is_same_v<CallableReturnType<L>, int>, "");
}

7.5.5 lambda-expressionis a prvalue whose result object is called theclosure object. [Note: A closure objectbehaves like a function object 

7.5.5.1  Closure types[expr.prim.lambda.closure]1
The type of alambda-expression(which is also the type of the closure object) is a unique, unnamed non-unionclass type, called theclosure type, whose properties are described below.

The lambda-expression’scompound-statement yields thefunction-body(9.5) of the function call operator,

void add_message_in_queue(const std::function<void()>&); // Эта функция ставит в очередь произвольный функтор без аргументов и возвратного значения.

// Эта функция должна взять произвольный функтор без возвратного значения, но с любым набором аргументов, и создать функтор с аргументами, который будет класть этот функтор в очередь, прибиндив аргументы
template<typename T>
auto defer(const T& fnc) -> typename std::function<typename stdext::call_traits<T>::signature> // stdext::call_traits<T> - это твои трейты, только в нижнем регистре :)
{
  std::function<typename stdext::call_traits<T>::signature> result = [fnc](???) // Вот что записать тут?
  {
    add_message_in_queue(???); // И тут
  };

  return result;
}

void main()
{
  auto x = [](int, float){};
  auto y = defer(x);

  y(1, 1.0f); // Должен не вызвать реализацию x, а положить его в очередь, прибиндив единицы как аргументы вызова к x.
}

W>Блин, когда 101% времени сидишь за прикладным кодом, голова вообще отказывается работать в направлении шаблонов

W>void add_message_in_queue(const std::function<void()>&); // Эта функция ставит в очередь произвольный функтор без аргументов и возвратного значения.

W>// Эта функция должна взять произвольный функтор без возвратного значения, но с любым набором аргументов, и создать функтор с аргументами, который будет класть этот функтор в очередь, прибиндив аргументы
W>template<typename T>
W>auto defer(const T& fnc) -> typename std::function<typename stdext::call_traits<T>::signature> // stdext::call_traits<T> - это твои трейты, только в нижнем регистре :)
W>{
W>  std::function<typename stdext::call_traits<T>::signature> result = [fnc](???) // Вот что записать тут?
W>  {
W>    add_message_in_queue(???); // И тут
W>  };
W>  return result;
W>

W>void main()
W>{
W>  auto x = [](int, float){};
W>  auto y = defer(x);

W>  y(1, 1.0f); // Должен не вызвать реализацию x, а положить его в очередь, прибиндив единицы как аргументы вызова к x.
W>}

W>

    typedef typename convert_2args_type<typename stdext::call_traits<T>::signature>::type args_tuple_type;
    std::function<typename stdext::call_traits<T>::signature> result = [fnc](args_tuple_type const& args)
     {
            // Здесь форейч по всем аргументам и в конце итерации вызов непосредственно функции 
        call_func_add_message_in_queue<0>(args);
        
     };

W>Блин, когда 101% времени сидишь за прикладным кодом, голова вообще отказывается работать в направлении шаблонов

W>template<typename T>
W>auto defer(const T& fnc) -> typename std::function<typename stdext::call_traits<T>::signature> // stdext::call_traits<T> - это твои трейты, только в нижнем регистре :)
W>{
W>  std::function<typename stdext::call_traits<T>::signature> result = [fnc](???) // Вот что записать тут?
W>  {
W>    add_message_in_queue(???); // И тут
W>  };

W>  return result;
W>}
W>

template<typename T>
auto defer(const T& fnc) -> typename std::function<typename stdext::call_traits<T>::signature> // stdext::call_traits<T> - это твои трейты, только в нижнем регистре :)
{
  std::function<typename stdext::call_traits<T>::signature> result = [fnc](auto&&...args)  // Вот что записать тут?
  {
    add_message_in_queue(fnc(std::forward<decltype(args)>(args)...)); // И тут
  };

  return result;
}

W>Блин, когда 101% времени сидишь за прикладным кодом, голова вообще отказывается работать в направлении шаблонов

template<typename Sig>
struct FunctionProxy
{
   typedef std::function<void()> fn_type;

   template<typename... Args>
   fn_type operator()(Args&&... args)
   {
      std::tuple<???> t(args); // тип из сигнатуры вытащить
      return [fn, t]() { std::apply(fn, t); };
   }

   std::function<Sig> fn;
}.

typedef TYPE_OF_PARAMETER(func(int(), int(), int(), int()), 3) third_parameter_type;

using namespace md;

namespace md {

void add_to_queue(const std::function<void()>& fnc)
{
  fnc(); // Для проверки просто вызываем
}

template<typename Sig>
struct defer_proxy
{
  template<typename... Args>
  void operator()(Args&&... args)
  {
    // Чтобы протащить в лямбду...
    stdext::call_traits<Sig>::parameter_types args_tuple(std::forward<Args>(args)...);  // Пакуем аргументы в туплу
    auto fn_ = std::move(fn);                                                           // И функцию в локал 

    add_to_queue([fn_, args_tuple](){stdext::call_elements(fn_, args_tuple);}); // call_elements = std::apply
  } 

  std::function<Sig> fn;
};


template<typename T>
auto defer(const T& fn) -> typename std::function<typename stdext::call_traits<T>::signature>
{
  return defer_proxy<typename stdext::call_traits<T>::signature>{fn};
}

} // md

int main(int argc, char * argv[])
{
  auto x = [](int i, float f)
  {
    std::cout << i << " " << f << std::endl;
  };
  defer(x)(1, 1.0f);

  std::function<void(int, float)> y = x;
  defer(y)(2, 2.0f);

  return 0;
}

    add_to_queue([fn_ = std::move(fn), args_tuple](){stdext::call_elements(fn_, args_tuple);});} // call_elements = std::apply

#include <iostream>
#include <functional>

namespace md {

void add_to_queue(const std::function<void()>& fnc)
{
  fnc(); // Для проверки просто вызываем
}

template<typename F, typename...Args>
void defer(F&& fn, Args&&...args)
{
  return add_to_queue([=](){fn(args...);});
}

} // md

int main(int argc, char * argv[])
{
  auto x = [](int i, float f)
  {
    std::cout << i << " " << f << std::endl;
  };
  md::defer(x, 1, 1.0f);

  std::function<void(int, float)> y = x;
  md::defer(y, 2, 2.0f);
}

#include <iostream>
#include <functional>

namespace md {

void add_to_queue(const std::function<void()>& fnc)
{
  fnc(); // Для проверки просто вызываем
}

template<typename F>
struct defer_proxy
{
  template<typename... Args>
  void operator()(Args&&... args) const
  {
    auto&& fn_ = fn;
    add_to_queue([=](){fn_(args...);}); // call_elements = std::apply
  } 
  F fn;
};


template<typename F>
defer_proxy<F> defer(const F& fn)
{
  return {fn};
}

} // md

int main(int argc, char * argv[])
{
  auto x = [](int i, float f)
  {
    std::cout << i << " " << f << std::endl;
  };
  md::defer(x)(1, 1.0f);

  std::function<void(int, float)> y = x;
  md::defer(y)(2, 2.0f);
}

// Какая-то демо-функция
void log(std::string text)
{
  log() << text;
}

Socket<void(std::string)> n_input;

int main()
{
  // Это код вызовет запись в лог немедленно
  n_input.connect(&log);
  n_input("Instant notification"); // То есть после этой строчки в логе уже надпись "Instant notification"
  n_input.disconnect_all();

  // А этот код покладет запись в лог в очередь, которая обработается "когда-то потом"
  n_input.connect(defer(&log));
  n_input("Defered notification"); // То есть после этой строчки в логе сразу ничего не появится

  process_queue(); // А после этой строчки - в логе появится "Defered notification"
}