SFINAE — The Silent enable_if Placement Mistake

#include <iostream>
#include <type_traits>

// Overload A — only enters the overload set when T is an integral type.
// The return type is computed: if T is integral, it resolves to void.
// If T is NOT integral, the expression is ill-formed → substitution failure → silently removed.
template <typename T>
typename std::enable_if<std::is_integral<T>::value, void>::type
describe(T value) {
    std::cout << value << " is an integer type\n";
}

// Overload B — enters the overload set only when T is a floating-point type.
template <typename T>
typename std::enable_if<std::is_floating_point<T>::value, void>::type
describe(T value) {
    std::cout << value << " is a floating-point type\n";
}

// Overload C — a catch-all for everything else (neither integral nor floating-point).
// std::enable_if with a negated condition: only active when both above are inactive.
template <typename T>
typename std::enable_if<
    !std::is_integral<T>::value && !std::is_floating_point<T>::value,
    void
>::type
describe(T /*value*/) {
    std::cout << "Type is neither integral nor floating-point\n";
}

int main() {
    describe(42);          // Selects Overload A — int is integral
    describe(3.14);        // Selects Overload B — double is floating-point
    describe("hello");     // Selects Overload C — const char* is neither

    // describe('A') would select Overload A — char IS integral in C++
    describe('A');         // Integral: char → prints as integer value 65

    return 0;
}

#include <iostream>
#include <string>
#include <type_traits>
#include <vector>

// ── void_t: C++11 compatible implementation ──────────────────────────────────
// Accepts any number of well-formed types, then collapses to void.
// If any type expression is invalid, the entire alias is ill-formed → SFINAE.
template <typename...>
using void_t = void;
// (This is std::void_t in C++17 — shown here so you understand what it really is.)

// ── Detector: does type T have a member function .serialize() ? ──────────────

// Primary template: assume T does NOT have serialize().
// 'HasSerialize::value' will be false_type for types without it.
template <typename T, typename = void>
struct HasSerialize : std::false_type {};

// Partial specialisation: only activates when decltype(&T::serialize) is a
// well-formed expression — i.e., T genuinely has a member called 'serialize'.
// void_t swallows the decltype result, producing void, matching the default
// second parameter 'void'. The specialisation wins over the primary.
template <typename T>
struct HasSerialize<T, void_t<decltype(&T::serialize)>> : std::true_type {};

// ── Detector: does type T have a nested type called 'value_type'? ────────────
template <typename T, typename = void>
struct HasValueType : std::false_type {};

template <typename T>
struct HasValueType<T, void_t<typename T::value_type>> : std::true_type {};

// ── Types to probe ────────────────────────────────────────────────────────────
struct JsonDocument {
    std::string serialize() const { return "{}"; }  // Has serialize()
};

struct RawBuffer {
    char data[256];  // No serialize(), no value_type
};

// ── Functions that use the detectors ─────────────────────────────────────────

// Only compiles into the overload set when T has serialize().
template <typename T>
typename std::enable_if<HasSerialize<T>::value, std::string>::type
convertToString(const T& obj) {
    return obj.serialize();  // Safe to call — we proved it exists at compile time
}

// Fallback: T doesn't have serialize(), so we return a placeholder.
template <typename T>
typename std::enable_if<!HasSerialize<T>::value, std::string>::type
convertToString(const T& /*obj*/) {
    return "[not serializable]";
}

int main() {
    JsonDocument doc;
    RawBuffer    buf;
    std::vector<int> numbers = {1, 2, 3};  // Has value_type, no serialize()

    std::cout << "JsonDocument has serialize(): "
              << std::boolalpha << HasSerialize<JsonDocument>::value << "\n";  // true
    std::cout << "RawBuffer has serialize():    "
              << HasSerialize<RawBuffer>::value    << "\n";  // false

    std::cout << "vector has value_type: "
              << HasValueType<std::vector<int>>::value << "\n";  // true
    std::cout << "RawBuffer has value_type: "
              << HasValueType<RawBuffer>::value        << "\n";  // false

    // SFINAE-based dispatch in action:
    std::cout << "\nconvertToString(doc): " << convertToString(doc) << "\n";
    std::cout << "convertToString(buf): " << convertToString(buf) << "\n";

    return 0;
}

#include <iostream>
#include <type_traits>
#include <string>

// ════════════════════════════════════════════════════════
// POSITION 1: Return type (classic, verbose)
// ════════════════════════════════════════════════════════

template <typename NumericType>
std::enable_if_t<std::is_arithmetic_v<NumericType>, std::string>
formatValue_returnPos(NumericType val) {
    // enable_if_t resolves to std::string only when NumericType is arithmetic.
    // If not arithmetic → std::string doesn't exist here → substitution failure → removed.
    return "[arithmetic] " + std::to_string(val);
}

// ════════════════════════════════════════════════════════
// POSITION 2: Template parameter list (preferred, clean)
// The second template param has a default — it doesn't appear in the call syntax.
// ════════════════════════════════════════════════════════

template <
    typename NumericType,
    // When condition is false, enable_if_t has no 'type' → ill-formed → SFINAE removal.
    // 'nullptr_t' is the type, '= nullptr' provides a default so callers don't pass it.
    std::enable_if_t<std::is_arithmetic_v<NumericType>, int> = 0
>
std::string formatValue_paramPos(NumericType val) {
    return "[arithmetic] " + std::to_string(val);
}

// Non-arithmetic overload that coexists cleanly:
template <
    typename StringLikeType,
    std::enable_if_t<!std::is_arithmetic_v<StringLikeType>, int> = 0
>
std::string formatValue_paramPos(const StringLikeType& val) {
    // This overload wins for std::string, const char*, and anything else non-arithmetic.
    // Conditions are mutually exclusive → no ambiguity, no compiler fights.
    (void)val; // silence unused-param warning in this demo
    return "[non-arithmetic]";
}

// ════════════════════════════════════════════════════════
// POSITION 3: Function parameter (avoid — shown for completeness)
// An extra 'phantom' parameter with a default value carries the constraint.
// Problem: it changes the visible function signature.
// ════════════════════════════════════════════════════════

template <typename NumericType>
std::string formatValue_funcParam(
    NumericType val,
    std::enable_if_t<std::is_arithmetic_v<NumericType>, int> = 0  // phantom param
) {
    return "[arithmetic] " + std::to_string(val);
}

int main() {
    // All three positions produce identical runtime behaviour:
    std::cout << formatValue_returnPos(42)       << "\n";  // Position 1
    std::cout << formatValue_returnPos(3.14f)    << "\n";  // Position 1

    std::cout << formatValue_paramPos(100)       << "\n";  // Position 2 — arithmetic
    std::cout << formatValue_paramPos(std::string("hello")) << "\n";  // Position 2 — non-arith

    std::cout << formatValue_funcParam(99)       << "\n";  // Position 3

    // formatValue_returnPos("oops");  // Would be a hard error — no non-arith overload for pos 1

    return 0;
}

#include <iostream>
#include <type_traits>
#include <concepts>    // C++20
#include <string>
#include <vector>

// ════════════════════════════════════════════════════════
// APPROACH A: Classic SFINAE (C++17 style)
// Works anywhere. Verbose. Error messages are cryptic when misused.
// ════════════════════════════════════════════════════════

template <typename ContainerType,
          std::enable_if_t<
              // Condition: T must have begin() and end() and a value_type
              std::is_same_v<
                  decltype(*std::declval<ContainerType>().begin()),
                  typename ContainerType::value_type&
              >,
              int
          > = 0>
void printAll_sfinae(const ContainerType& container) {
    std::cout << "[SFINAE] Contents: ";
    for (const auto& element : container) {
        std::cout << element << " ";
    }
    std::cout << "\n";
}

// ════════════════════════════════════════════════════════
// APPROACH B: C++20 Concepts — same constraint, crystal clear
// The compiler error if you call this with int? "int doesn't satisfy 'Iterable'".
// ════════════════════════════════════════════════════════

// Define a named concept: T is Iterable if you can call begin() and end() on it.
concept Iterable = requires(ContainerT container) {
    { container.begin() } -> std::input_or_output_iterator;
    { container.end()   } -> std::input_or_output_iterator;
};

template <Iterable ContainerType>
void printAll_concepts(const ContainerType& container) {
    std::cout << "[Concepts] Contents: ";
    for (const auto& element : container) {
        std::cout << element << " ";
    }
    std::cout << "\n";
}

// Subsumption: a more-specific concept is preferred — no mutual exclusion needed.
// This overload also requires the elements to be printable (streamable).
concept PrintableIterable = Iterable<ContainerT> && requires(ContainerT c) {
    // Each element must be streamable to std::ostream
    { std::cout << *c.begin() };
};

// This overload wins over the plain Iterable version when both apply,
// because PrintableIterable *subsumes* Iterable — more constrained wins.
template <PrintableIterable ContainerType>
void printAll_concepts(const ContainerType& container) {
    std::cout << "[Concepts/Printable] Printing " << container.size() << " items: ";
    for (const auto& element : container) {
        std::cout << element << " ";
    }
    std::cout << "\n";
}

int main() {
    std::vector<int>         numbers = {10, 20, 30};
    std::vector<std::string> words   = {"alpha", "beta", "gamma"};

    // SFINAE versions:
    printAll_sfinae(numbers);  // Works
    printAll_sfinae(words);    // Works

    // Concepts versions (subsumed — PrintableIterable overload wins for both):
    printAll_concepts(numbers); // PrintableIterable overload selected
    printAll_concepts(words);   // PrintableIterable overload selected

    // printAll_sfinae(42);     // Hard error: substitution failure with no fallback
    // printAll_concepts(42);   // Clear error: "int does not satisfy Iterable"

    return 0;
}

#include <iostream>
#include <type_traits>
#include <vector>
#include <list>
#include <string>

// ── Helper: void_t ───────────────────────────────────────────────────
template <typename...>
using void_t = void;

// ── Detector: does T support reserve(size_t)? ─────────────────────────
template <typename T, typename = void>
struct HasReserve : std::false_type {};

template <typename T>
struct HasReserve<T, void_t<decltype(std::declval<T&>().reserve(0))>> : std::true_type {};

// ── Generic function that reserves capacity if possible, else does nothing ──
template <typename Container>
std::enable_if_t<HasReserve<Container>::value>
maybe_reserve(Container& c, std::size_t n) {
    c.reserve(n);
    std::cout << "Reserved " << n << " elements\n";
}

template <typename Container>
std::enable_if_t<!HasReserve<Container>::value>
maybe_reserve(Container& c, std::size_t n) {
    (void)c; (void)n;
    std::cout << "No reserve, ignored\n";
}

int main() {
    std::vector<int> v;
    std::list<int>   l;
    std::string      s;

    std::cout << "vector has reserve: " << HasReserve<decltype(v)>::value << "\n"; // true
    std::cout << "list has reserve:   " << HasReserve<decltype(l)>::value << "\n"; // false
    std::cout << "string has reserve: " << HasReserve<decltype(s)>::value << "\n"; // true (since C++11)

    maybe_reserve(v, 100);  // "Reserved 100 elements"
    maybe_reserve(l, 100);  // "No reserve, ignored"
    maybe_reserve(s, 100);  // "Reserved 100 elements"

    return 0;
}