template <typename F, typename...Args>
void ForEach(F&& f, Args&&...args)
{
   //???
}

template <typename F, typename...Args>
void ForEach(F&& f, Args&&...args)
{
   auto wrapper = [&](auto&& t){ f(std::forward<decltype(t)>(t)); return 0; };
   std::initializer_list<int>{ wrapper(std::forward<Args>(args))... };
}
}

template<typename F, typename... Args>
void for_all(F &&f, Args&& ...args) {
   (std::forward<F>(f)(std::forward<Args>(args)), ...);
}

(std::forward<F>(f)(std::forward<Args>(args))...);

#include <iostream>

template<typename F, typename ...Args>
bool for_all(F &&f, Args&& ...args) {
   return (std::forward<F>(f)(std::forward<Args>(args)) && ...);
}

int main()
{
    auto f = [](auto &&v) { std::cout << v << std::endl; return true; };
    return for_all(f, 1, 3.14, '4', "5");
}

template <typename...Args>
std::ostream& PrintAll(std::ostream& output, Args&&...args)
{
    return (output << ... << args) << std::endl;
}

X>  std::forward<F>(f)

vector<int> v0, v1, v2, v3;
// fill v0

v1 = v0;
v2 = v0;
v3 = v0;

v1 = std::move(v0);
v2 = std::move(v0);
v3 = std::move(v0);

X>>  std::forward<F>(f)
W>

W>Не самый очевидный способ оставить в коде бомбу замедленного действия

namespace detail {

template <class F, class... Args>
auto INVOKE(F&& f, Args&&... args)
    noexcept(noexcept(std::forward<F>(f)(std::forward<Args>(args)...)))
 -> std::enable_if_t<!std::is_member_pointer_v<std::decay_t<F>>,
    decltype(std::forward<F>(f)(std::forward<Args>(args)...))>
{
      return std::forward<F>(f)(std::forward<Args>(args)...);
}

} // namespace detail
 
template< class F, class... ArgTypes >
auto invoke(F&& f, ArgTypes&&... args)
    // exception specification for QoI
    noexcept(noexcept(detail::INVOKE(std::forward<F>(f), std::forward<ArgTypes>(args)...)))
 -> decltype(detail::INVOKE(std::forward<F>(f), std::forward<ArgTypes>(args)...))
{
    return detail::INVOKE(std::forward<F>(f), std::forward<ArgTypes>(args)...);
}

std::move(f)(1);
std::move(f)(2);
std::move(f)(3);

         (f)(1);
         (f)(2);
         (f)(3);

         (f)(1);
         (f)(2);
std::move(f)(3);

R>template <typename F, typename...Args>
R>void ForEach(F&& f, Args&&...args)
R>{
R>   auto wrapper = [&](auto&& t){ f(std::forward<decltype(t)>(t)); return 0; };
R>   std::initializer_list<int>{ wrapper(std::forward<Args>(args))... };
R>}
R>}
R>

#include <iostream>
#include <utility>

template <typename F, typename...Args>
void ForEach(F&& f, Args&&...args)
{
   //auto wrapper = [&](auto&& t){ f(std::forward<decltype(t)>(t)); return 0; };
   auto v = {(f(args),0) ... };
   //тут написать что-то , чтобы компилятор не ругался на неиспользуемую переменную
   (void) v;
}

int main()
{
   ForEach([](auto&& t){ std::cout << t; }, "Pi = ", 3.14);
}

template<typename F, typename A0, typename A1>
void func(F &&f, A0 &&a0, A1 &&a1) {
   std::move(f)(std::forward<A0>(a0));
   std::move(f)(std::forward<A1>(a1));
}