conventions/

conventions.rs

use waddling_errors::prelude::*;

// # Sequence Conventions Example
//
// This example demonstrates the recommended sequence conventions
// for the Waddling ecosystem.
//
// Run with: `cargo run --example conventions`

fn main() {
    println!("🦆 Waddling Error Sequence Conventions Demo\n");
    println!("═══════════════════════════════════════════════════\n");

    // ========================================================================
    // CONVENTIONAL SEQUENCES (001-030)
    // ========================================================================

    println!("✅ CONVENTIONAL SEQUENCES (Recommended)\n");

    // Core Errors (001-010)
    println!("Core Errors (001-010):");

    const ERR_MISSING: Code = error("CRYPTO", "SALT", 1);
    println!(
        "  {} - .001 = MISSING (required item not provided)",
        ERR_MISSING.code()
    );

    const ERR_MISMATCH: Code = error("CRYPTO", "LENGTH", 2);
    println!(
        "  {} - .002 = MISMATCH (values don't match)",
        ERR_MISMATCH.code()
    );

    const ERR_INVALID: Code = error("PATTERN", "REGEX", 3);
    println!(
        "  {} - .003 = INVALID (format/validation failed)",
        ERR_INVALID.code()
    );

    const ERR_OVERFLOW: Code = error("BUFFER", "SIZE", 4);
    println!(
        "  {} - .004 = OVERFLOW (value too large)",
        ERR_OVERFLOW.code()
    );

    const ERR_TIMEOUT: Code = blocked("NETWORK", "CONN", 7);
    println!(
        "  {} - .007 = TIMEOUT (operation timed out)",
        ERR_TIMEOUT.code()
    );

    const WARN_DEPRECATED: Code = warning("API", "FUNC", 10);
    println!(
        "  {} - .010 = DEPRECATED (feature deprecated)\n",
        WARN_DEPRECATED.code()
    );

    // State/Lifecycle Errors (011-020)
    println!("State/Lifecycle Errors (011-020):");

    const ERR_UNINITIALIZED: Code = error("ENGINE", "STATE", 11);
    println!(
        "  {} - .011 = UNINITIALIZED (not initialized)",
        ERR_UNINITIALIZED.code()
    );

    const ERR_ALREADYINIT: Code = error("ENGINE", "STATE", 12);
    println!(
        "  {} - .012 = ALREADYINIT (already initialized)",
        ERR_ALREADYINIT.code()
    );

    const ERR_CLOSED: Code = error("STREAM", "STATE", 13);
    println!("  {} - .013 = CLOSED (resource closed)", ERR_CLOSED.code());

    const BLOCKED_INPROGRESS: Code = blocked("TASK", "STATE", 15);
    println!(
        "  {} - .015 = INPROGRESS (operation in progress)\n",
        BLOCKED_INPROGRESS.code()
    );

    // Resource Errors (021-030)
    println!("Resource Errors (021-030):");

    const ERR_NOTFOUND: Code = error("DATA", "KEY", 21);
    println!(
        "  {} - .021 = NOTFOUND (resource not found)",
        ERR_NOTFOUND.code()
    );

    const ERR_ALREADYEXISTS: Code = error("FILE", "CREATE", 22);
    println!(
        "  {} - .022 = ALREADYEXISTS (already exists)",
        ERR_ALREADYEXISTS.code()
    );

    const CRIT_EXHAUSTED: Code = critical("MEM", "ALLOC", 23);
    println!(
        "  {} - .023 = EXHAUSTED (resource exhausted)",
        CRIT_EXHAUSTED.code()
    );

    const BLOCKED_LOCKED: Code = blocked("THREAD", "MUTEX", 24);
    println!(
        "  {} - .024 = LOCKED (resource locked)",
        BLOCKED_LOCKED.code()
    );

    const CRIT_CORRUPTED: Code = critical("CRYPTO", "MAC", 25);
    println!(
        "  {} - .025 = CORRUPTED (data corrupted)\n",
        CRIT_CORRUPTED.code()
    );

    // ========================================================================
    // PROJECT-SPECIFIC SEQUENCES (031-897)
    // ========================================================================

    println!("═══════════════════════════════════════════════════\n");
    println!("✨ PROJECT-SPECIFIC SEQUENCES (Free Use)\n");
    println!("Domain-Specific Range (031-897):");

    const ERR_HMAC_COMPUTE: Code = error("CRYPTO", "HMAC", 31);
    println!(
        "  {} - Domain-specific (HMAC computation)",
        ERR_HMAC_COMPUTE.code()
    );

    const ERR_PATTERN_COMPLEX: Code = warning("PATTERN", "PERF", 45);
    println!(
        "  {} - Domain-specific (pattern complexity)",
        ERR_PATTERN_COMPLEX.code()
    );

    const ERR_AST_MALFORMED: Code = error("parser", "AST", 51);
    println!(
        "  {} - Domain-specific (AST structure)\n",
        ERR_AST_MALFORMED.code()
    );

    // ========================================================================
    // SUCCESS SEQUENCES (998-999)
    // ========================================================================

    println!("═══════════════════════════════════════════════════\n");
    println!("🎉 SUCCESS SEQUENCES (Positive Outcomes)\n");
    println!("Success Range (998-999):");

    const SUCCESS_PARTIAL: Code = success("BUILD", "RESULT", 998);
    println!(
        "  {} - .998 = PARTIAL (partial success)",
        SUCCESS_PARTIAL.code()
    );

    const SUCCESS_COMPLETE: Code = success("REDACT", "DONE", 999);
    println!(
        "  {} - .999 = COMPLETE (full completion)",
        SUCCESS_COMPLETE.code()
    );

    const COMPLETE_COMPILE: Code = completed("BUILD", "DONE", 999);
    println!(
        "  {} - .999 = COMPLETE (compilation finished)\n",
        COMPLETE_COMPILE.code()
    );

    // ========================================================================
    // CROSS-PROJECT CONSISTENCY
    // ========================================================================

    println!("═══════════════════════════════════════════════════\n");
    println!("🌐 CROSS-PROJECT CONSISTENCY\n");
    println!("Same semantic meaning across different projects:\n");

    // "Missing" errors across different projects
    const DUCOY_MISSING: Code = error("CRYPTO", "SALT", 1);
    println!("Ducoy:      {} (.001 = MISSING)", DUCOY_MISSING.code());

    const QUACKPATCH_MISSING: Code = error("parser", "TOKEN", 1);
    println!("QuackPatch: {} (.001 = MISSING)", QUACKPATCH_MISSING.code());

    const STATEQUACK_MISSING: Code = error("STATE", "KEY", 1);
    println!(
        "StateQuack: {} (.001 = MISSING)\n",
        STATEQUACK_MISSING.code()
    );

    println!("👆 Notice: .001 ALWAYS means \"missing\" - instant recognition!\n");

    // ========================================================================
    // BENEFITS
    // ========================================================================

    println!("═══════════════════════════════════════════════════\n");
    println!("💡 BENEFITS OF CONVENTIONS\n");
    println!("  ✅ Instant Recognition");
    println!("     .001 anywhere → \"missing\" error\n");
    println!("  ✅ Cross-Project Learning");
    println!("     Understand Ducoy → understand all Waddling projects\n");
    println!("  ✅ Searchability");
    println!("     Search .001 finds all \"missing\" errors ecosystem-wide\n");
    println!("  ✅ Predictability");
    println!("     Users can guess meanings from sequences alone\n");
    println!("  ✅ Documentation");
    println!("     Document patterns once, reference everywhere\n");

    println!("═══════════════════════════════════════════════════\n");
    println!("📚 Full documentation: docs/SEQUENCE-CONVENTIONS.md");
    println!("🔧 Enforcement strategies: docs/ENFORCEMENT.md\n");
}