Parameter Packs and Fold Expressions

// Base case: no arguments left
void print() {
    std::cout << '\n';
}

// Recursive case: handle first argument, recurse for the rest
// 'First' is the head; 'Rest...' is the tail (zero or more remaining)
template<typename First, typename... Rest>
void print(const First& first, const Rest&... rest) {
    std::cout << first;
    if constexpr (sizeof...(rest) > 0) {
        std::cout << ", ";
    }
    print(rest...);  // Recurse with the remaining arguments
    // Each recursive call instantiates a new function with one
    // fewer parameter, until we hit print() — the base case.
}

// Sum any number of arguments (right fold)
template<typename... Args>
auto sum(Args... args) {
    return (args + ...);
    // If args = {1, 2, 3, 4}, expands to:
    //   1 + (2 + (3 + 4))
    // = 1 + (2 + 7)
    // = 1 + 9
    // = 10
}

// Sum with an initial value (left fold with init)
// Handles empty pack: sum_safe() returns 0
template<typename... Args>
auto sum_safe(Args... args) {
    return (0 + ... + args);
    // If args is empty, this is just 0.
    // If args = {1, 2, 3}, expands to:
    //   ((0 + 1) + 2) + 3
}

// Product with initial value
template<typename... Args>
auto product(Args... args) {
    return (1 * ... * args);
    // Empty pack returns 1 (multiplicative identity)
}

// Print all arguments separated by spaces (no recursion!)
template<typename... Args>
void print_all(const Args&... args) {
    // Left fold over comma: ((cout << a1, cout << " "), (cout << a2, cout << " ")), ...
    // The inner lambda handles the formatting per element
    bool first = true;
    auto print_one = [&first](const auto& arg) {
        if (!first) std::cout << ", ";
        std::cout << arg;
        first = false;
    };
    (print_one(args), ...);  // Fold over comma: calls print_one for each arg
    std::cout << '\n';
}

template<typename... Args>
void show_count(Args... args) {
    // sizeof... counts the elements in the pack
    constexpr auto count = sizeof...(Args);  // or sizeof...(args) — same result
    std::cout << std::format("  Pack contains {} element(s)\n", count);

    // sizeof...(Args) and sizeof...(args) always return the same value.
    // The first counts type parameters, the second counts value parameters.
    // They're in lockstep, so use whichever reads better.
    static_assert(sizeof...(Args) == sizeof...(args));
}

// A factory function that constructs any type with any arguments
template<typename T, typename... Args>
std::unique_ptr<T> create(Args&&... args) {
    // std::forward<Args>(args)... expands BOTH packs in lockstep:
    // If Args = {int, const string&, double}, args = {a, b, c}:
    //   std::forward<int>(a), std::forward<const string&>(b), std::forward<double>(c)
    return std::make_unique<T>(std::forward<Args>(args)...);
}

struct Point {
    double x, y, z;
    Point(double x, double y, double z) : x(x), y(y), z(z) {}
};

// Base case: empty tuple
template<typename... Ts>
struct SimpleTuple {};

// Recursive case: store Head, inherit rest
template<typename Head, typename... Tail>
struct SimpleTuple<Head, Tail...> : SimpleTuple<Tail...> {
    Head value_;

    // Constructor: initialize our element, forward the rest to base
    SimpleTuple(Head head, Tail... tail)
        : SimpleTuple<Tail...>(tail...), value_(head) {}
};

// Helper to get the Nth element (0-indexed)
// This uses recursive template specialization to "count down" to N=0
template<std::size_t N, typename Head, typename... Tail>
struct TupleGet {
    static auto& get(SimpleTuple<Head, Tail...>& t) {
        // Not at index 0 yet — skip Head and recurse into the base
        return TupleGet<N - 1, Tail...>::get(
            static_cast<SimpleTuple<Tail...>&>(t)
        );
    }
};

template<typename Head, typename... Tail>
struct TupleGet<0, Head, Tail...> {
    static Head& get(SimpleTuple<Head, Tail...>& t) {
        return t.value_;  // N == 0, this is the element we want
    }
};

// Convenience function
template<std::size_t N, typename... Ts>
auto& get(SimpleTuple<Ts...>& t) {
    return TupleGet<N, Ts...>::get(t);
}

// Check that ALL arguments satisfy a concept
template<typename... Args>
concept AllPrintable = (requires(std::ostream& os, Args args) {
    { os << args };
} && ...);
// The && ... is a fold over the concept constraint itself!
// Each Args element must support os << arg.

template<typename... Args>
    requires AllPrintable<Args...>
void log_message(const std::string& prefix, const Args&... args) {
    std::cout << "[" << prefix << "] ";
    // Fold with comma — print each arg with a separator
    ((std::cout << args << " "), ...);
    std::cout << '\n';
}

// Are ALL types integral?
template<typename... Ts>
constexpr bool all_integral = (std::is_integral_v<Ts> && ...);

// Is ANY type a floating point?
template<typename... Ts>
constexpr bool any_floating = (std::is_floating_point_v<Ts> || ...);

// Are ALL types the same?
template<typename First, typename... Rest>
constexpr bool all_same = (std::is_same_v<First, Rest> && ...);