Adding variadic math functions like min, max etc. about functionalplus HOT 7 CLOSED

#include <vector>
#include <functional>
#include <utility>
#include <type_traits>
#include <iostream>
#include <chrono>

template <typename TimeT = std::chrono::milliseconds>
struct measure
{
  template <typename F, typename... Args>
  static typename TimeT::rep execution(F func, Args &&... args)
  {
    auto start = std::chrono::system_clock::now();

    // Now call the function with all the parameters you need.
    func(std::forward<Args>(args)...);

    auto duration = std::chrono::duration_cast<TimeT>(std::chrono::system_clock::now() - start);

    return duration.count();
  }
};

#ifdef VARIADIC
template <typename U, typename... V>
auto min(const U &u, const V &... v)
{
  using rettype = typename std::common_type_t<U, V...>;
  rettype result = static_cast<rettype>(u);
  (void)std::initializer_list<bool>{((v < result) ? (result = static_cast<rettype>(v), false) : false)...};
  return result;
}
#else
// API search type: min_2 : (a, a) -> a
// Minimum of two values.
template <typename X>
const X &min_2(const X &a, const X &b)
{
  return std::min(a, b);
}

// API search type: min_3 : (a, a, a) -> a
// Minimum of three values.
template <typename X>
const X &min_3(const X &a, const X &b, const X &c)
{
  return min_2(min_2(a, b), c);
}

// API search type: min_4 : (a, a, a, a) -> a
// Minimum of four values.
template <typename X>
const X &min_4(const X &a, const X &b, const X &c, const X &d)
{
  return min_2(min_3(a, b, c), d);
}

// API search type: min_5 : (a, a, a, a, a) -> a
// Minimum of five values.
template <typename X>
const X &min_5(const X &a, const X &b, const X &c, const X &d, const X &e)
{
  return min_3(min_3(a, b, c), d, e);
}
#endif

int main()
{
  constexpr int COUNT = 50000000;

#ifdef VARIADIC
  std::vector<int> v;
  v.reserve(COUNT);
  std::cout << "variadic version: " << '\n';
  std::cout << measure<std::chrono::milliseconds>::execution([&v]()
                                                             {
                                                               for (int i = -COUNT; i < COUNT; ++i)
                                                                 v.emplace_back(min(1, -14, 3, -1, i));

                                                             }) << "ms\n";
#else
  std::vector<int> v1;
  v1.reserve(COUNT);
  std::cout << "functional plus version: " << '\n';
  std::cout << measure<std::chrono::milliseconds>::execution([&v1]()
                                                             {
                                                               for (int i = -COUNT; i < COUNT; ++i)
                                                                 v1.emplace_back(min_5(1, -14, 3, -1, i));

                                                             }) << "ms\n";
#endif
}

template <typename U, typename... V>
auto min(const U &u, const V &... v) -> typename std::common_type<U, V...>::type
{
    using rettype = typename std::common_type<U, V...>::type;
    rettype result = static_cast<rettype>(u);
    (void)std::initializer_list<bool>{((v < result) ? (result = static_cast<rettype>(v), false) : false)...};
    return result;

}