Type Safety, Assertions & Contracts

#include <iostream>
#include <cstdint>

// BAD: Old-style enum — pollutes scope, implicit int conversion
// enum Color { Red, Green, Blue };
// enum TrafficLight { Red, Yellow, Green };  // ERROR: Red, Green redefined!

// GOOD: enum class — scoped and type-safe
enum class Color : std::uint8_t {
    Red   = 0,
    Green = 1,
    Blue  = 2
};

enum class TrafficLight {
    Red,
    Yellow,
    Green   // No conflict with Color::Green
};

void set_pixel(Color c) {
    // Color values cannot accidentally be used as integers
    // int x = c;  // ERROR: no implicit conversion
    auto x = static_cast<std::uint8_t>(c);  // explicit conversion OK
    std::cout << "Color value: " << static_cast<int>(x) << '\n';
}

int main() {
    set_pixel(Color::Blue);
    // set_pixel(2);               // ERROR: int is not Color
    // set_pixel(TrafficLight::Red); // ERROR: wrong enum type

    // Switch with enum class — compiler warns about unhandled cases
    TrafficLight light = TrafficLight::Red;
    switch (light) {
        case TrafficLight::Red:    std::cout << "Stop\n";    break;
        case TrafficLight::Yellow: std::cout << "Caution\n"; break;
        case TrafficLight::Green:  std::cout << "Go\n";      break;
        // No default — compiler warns if a case is missing
    }
}

#include <iostream>
#include <compare>

// Problem: easy to swap width and height — compiles silently
// void resize(int width, int height);
// resize(height, width);  // Bug! Compiles fine.

// Solution: distinct types for Width and Height
struct Width {
    int value;
    explicit Width(int v) : value(v) {}
    auto operator<=>(const Width&) const = default;
};

struct Height {
    int value;
    explicit Height(int v) : value(v) {}
    auto operator<=>(const Height&) const = default;
};

void resize(Width w, Height h) {
    std::cout << "Resizing to " << w.value << "x" << h.value << '\n';
}

// For units that need arithmetic, use a tagged type template
template<typename Tag, typename T = double>
struct StrongType {
    T value;
    explicit StrongType(T v) : value(v) {}
    auto operator<=>(const StrongType&) const = default;
};

using Meters    = StrongType<struct MetersTag>;
using Seconds   = StrongType<struct SecondsTag>;
using Kilograms = StrongType<struct KilogramsTag>;

void apply_force(Kilograms mass, Meters distance) {
    std::cout << "Force applied: " << mass.value
              << " kg over " << distance.value << " m\n";
}

int main() {
    resize(Width{800}, Height{600});   // Correct — types enforce order
    // resize(Height{600}, Width{800}); // ERROR: type mismatch!

    apply_force(Kilograms{10.0}, Meters{5.0});
    // apply_force(Meters{5.0}, Kilograms{10.0}); // ERROR!
}

#include <type_traits>
#include <cstdint>

// Ensure platform assumptions hold
static_assert(sizeof(int) >= 4,
    "This code requires int to be at least 32 bits");

static_assert(sizeof(void*) == 8,
    "This code requires a 64-bit platform");

// Enforce type constraints in templates
template<typename T>
class NumericBuffer {
    static_assert(std::is_arithmetic_v<T>,
        "NumericBuffer only works with numeric types");

    static_assert(!std::is_same_v<T, bool>,
        "NumericBuffer does not support bool (use bitset instead)");

public:
    void push(T value) { /* ... */ }
};

// Enforce struct layout for serialization
struct NetworkPacket {
    std::uint32_t source_ip;
    std::uint32_t dest_ip;
    std::uint16_t source_port;
    std::uint16_t dest_port;
    std::uint32_t sequence;
};

static_assert(sizeof(NetworkPacket) == 16,
    "NetworkPacket must be exactly 16 bytes for wire format");

int main() {
    NumericBuffer<double> buf;  // OK
    buf.push(3.14);

    // NumericBuffer<std::string> bad;  // ERROR: not arithmetic
    // NumericBuffer<bool> bad2;        // ERROR: bool not supported
}