Enum Language 

pub enum Language {
    Python,
    Rust,
    JavaScript,
    TypeScript,
    Go,
    Bash,
    C,
    Cpp,
    Java,
    MechGen,
    Ideal,
}

Languages with curated agentic profiles.

Variants

Python

Rust

JavaScript

TypeScript

Go

Bash

C

Cpp

Java

MechGen

MechGen — the agentic-first language (token-budgeted syntax, Agentic Binary Language binary IR target, self-healing compiler). Included because this crate’s parent ecosystem ships it; scored on the same axes as everything else.

Ideal

Ideal — a DESIGN TARGET, not an implemented language. Represents the composite ceiling for a text language an LLM writes, derived by maximizing each designable axis and accepting the irreducible token floor (see IDEAL_AGENTIC_LANGUAGE.md). It is NOT a measurement; it marks the boundary of what’s achievable so real languages can be read against it. Composite ≈ 0.90 — the token axis caps it.

Implementations

impl Language

pub fn all() -> [Language; 11]

All profiled languages, in fixed (deterministic) order.

Examples found in repository

examples/swe_lang_profiles.rs (line 40)

fn real_languages() -> Vec<LanguageProfile> {
    Language::all()
        .iter()
        .filter(|&&l| l != Language::Ideal)
        .map(|&l| profile(l))
        .collect()
}

examples/swe_languages.rs (line 54)

fn main() {
    println!("=== Agentic-SWE language comparison ===\n");

    // ── 1. Canonical agentic fitness (unweighted mean) ────────────────────────
    println!("CANONICAL agentic fitness (unweighted mean of the four axes)");
    println!(
        "{:<12} {:>7}   {:>6} {:>6} {:>6} {:>6}",
        "language", "fitness", "token", "determ", "reliab", "safety"
    );
    for p in rank_languages() {
        let tag = match p.language {
            Language::Ideal => "  ← design-target ceiling (not a real language)",
            Language::MechGen => "  ← this project's language (bias-audited)",
            _ => "",
        };
        println!(
            "{:<12} {:>7.3}   {:>6.2} {:>6.2} {:>6.2} {:>6.2}{}",
            p.language.name(),
            p.fitness(),
            p.token_efficiency,
            p.determinism,
            p.reliability,
            p.safety,
            tag,
        );
    }

    // ── 2. SWE-weighted ranking ───────────────────────────────────────────────
    println!("\nSWE-WEIGHTED ranking (reliability .35, determinism .30, safety .20, token .15)");
    let mut ranked: Vec<LanguageProfile> = Language::all().iter().map(|&l| profile(l)).collect();
    ranked.sort_by(|a, b| swe_score(b).partial_cmp(&swe_score(a)).unwrap());
    println!("{:<12} {:>9}   vs canonical", "language", "swe-score");
    for p in &ranked {
        let delta = swe_score(p) - p.fitness();
        let note = if p.language == Language::Ideal {
            "  (design target)"
        } else {
            ""
        };
        println!(
            "{:<12} {:>9.3}   {:+.3}{}",
            p.language.name(),
            swe_score(p),
            delta,
            note,
        );
    }
    println!(
        "  (the SWE lens lifts strongly-typed/reproducible languages — Rust, MechGen, Go —\n   \
         and demotes terse-but-unsafe ones — Python, Bash — vs the unweighted mean.)"
    );

    // ── 3. Head-to-head: MechGen vs the popular real languages ─────────────────
    println!("\nHEAD-TO-HEAD (positive = MechGen fits agentic SWE better)");
    for other in [Language::Rust, Language::Python, Language::Go, Language::TypeScript] {
        let c = compare_languages(Language::MechGen, other);
        print!("{c}");
    }

    // ── 4. Reading + honesty ──────────────────────────────────────────────────
    let mg = profile(Language::MechGen);
    let rust = profile(Language::Rust);
    let py = profile(Language::Python);
    println!("READING");
    println!(
        "  Among IMPLEMENTED languages MechGen ranks #1 ({:.3}); only the `ideal` DESIGN TARGET\n  \
         ({:.3}, token-floored, unreachable for any text language) sits above it.",
        mg.fitness(),
        profile(Language::Ideal).fitness()
    );
    println!(
        "  Under the SWE weighting it stays #1 among real languages: its reliability ({:.2}) and\n  \
         determinism ({:.2}) — sound effects, exhaustiveness, machine-readable fixes, byte-stable IR —\n  \
         are exactly what the build→test→debug loop rewards.",
        mg.reliability, mg.determinism
    );
    println!("\nHONESTY (this is the project's own language — bias is the risk):");
    println!(
        "  • Scores move on EVIDENCE, both ways: token was corrected DOWN 0.73→0.60 (a C/Go\n    \
         head-to-head exposed the old surface as MORE verbose), then RAISED 0.60→0.80 after the\n    \
         ab-initio migration LANDED type inference + `;`-removal (1166 tests green) and measured\n    \
         #1 of six on the real-BPE swe_token_benchmark. Composite was also corrected 0.95→0.865.");
    println!(
        "  • Falsifiable guards still hold: token ({:.2}) ≤ Python ({:.2}) — measured tersest but\n    \
         scored at parity, not above; reliability ({:.2}) ≤ Rust ({:.2}); no axis ≥ 0.98 (prototype).",
        mg.token_efficiency, py.token_efficiency, mg.reliability, rust.reliability
    );
    println!(
        "  • The advantage is real on the axes SWE cares about (reliability/determinism/safety),\n    \
         NOT on tokens — and it is a young prototype vs battle-tested Rust on correctness maturity."
    );
}

pub fn name(self) -> &'static str

Canonical lowercase name.

Examples found in repository

examples/swe_languages.rs (line 42)

fn main() {
    println!("=== Agentic-SWE language comparison ===\n");

    // ── 1. Canonical agentic fitness (unweighted mean) ────────────────────────
    println!("CANONICAL agentic fitness (unweighted mean of the four axes)");
    println!(
        "{:<12} {:>7}   {:>6} {:>6} {:>6} {:>6}",
        "language", "fitness", "token", "determ", "reliab", "safety"
    );
    for p in rank_languages() {
        let tag = match p.language {
            Language::Ideal => "  ← design-target ceiling (not a real language)",
            Language::MechGen => "  ← this project's language (bias-audited)",
            _ => "",
        };
        println!(
            "{:<12} {:>7.3}   {:>6.2} {:>6.2} {:>6.2} {:>6.2}{}",
            p.language.name(),
            p.fitness(),
            p.token_efficiency,
            p.determinism,
            p.reliability,
            p.safety,
            tag,
        );
    }

    // ── 2. SWE-weighted ranking ───────────────────────────────────────────────
    println!("\nSWE-WEIGHTED ranking (reliability .35, determinism .30, safety .20, token .15)");
    let mut ranked: Vec<LanguageProfile> = Language::all().iter().map(|&l| profile(l)).collect();
    ranked.sort_by(|a, b| swe_score(b).partial_cmp(&swe_score(a)).unwrap());
    println!("{:<12} {:>9}   vs canonical", "language", "swe-score");
    for p in &ranked {
        let delta = swe_score(p) - p.fitness();
        let note = if p.language == Language::Ideal {
            "  (design target)"
        } else {
            ""
        };
        println!(
            "{:<12} {:>9.3}   {:+.3}{}",
            p.language.name(),
            swe_score(p),
            delta,
            note,
        );
    }
    println!(
        "  (the SWE lens lifts strongly-typed/reproducible languages — Rust, MechGen, Go —\n   \
         and demotes terse-but-unsafe ones — Python, Bash — vs the unweighted mean.)"
    );

    // ── 3. Head-to-head: MechGen vs the popular real languages ─────────────────
    println!("\nHEAD-TO-HEAD (positive = MechGen fits agentic SWE better)");
    for other in [Language::Rust, Language::Python, Language::Go, Language::TypeScript] {
        let c = compare_languages(Language::MechGen, other);
        print!("{c}");
    }

    // ── 4. Reading + honesty ──────────────────────────────────────────────────
    let mg = profile(Language::MechGen);
    let rust = profile(Language::Rust);
    let py = profile(Language::Python);
    println!("READING");
    println!(
        "  Among IMPLEMENTED languages MechGen ranks #1 ({:.3}); only the `ideal` DESIGN TARGET\n  \
         ({:.3}, token-floored, unreachable for any text language) sits above it.",
        mg.fitness(),
        profile(Language::Ideal).fitness()
    );
    println!(
        "  Under the SWE weighting it stays #1 among real languages: its reliability ({:.2}) and\n  \
         determinism ({:.2}) — sound effects, exhaustiveness, machine-readable fixes, byte-stable IR —\n  \
         are exactly what the build→test→debug loop rewards.",
        mg.reliability, mg.determinism
    );
    println!("\nHONESTY (this is the project's own language — bias is the risk):");
    println!(
        "  • Scores move on EVIDENCE, both ways: token was corrected DOWN 0.73→0.60 (a C/Go\n    \
         head-to-head exposed the old surface as MORE verbose), then RAISED 0.60→0.80 after the\n    \
         ab-initio migration LANDED type inference + `;`-removal (1166 tests green) and measured\n    \
         #1 of six on the real-BPE swe_token_benchmark. Composite was also corrected 0.95→0.865.");
    println!(
        "  • Falsifiable guards still hold: token ({:.2}) ≤ Python ({:.2}) — measured tersest but\n    \
         scored at parity, not above; reliability ({:.2}) ≤ Rust ({:.2}); no axis ≥ 0.98 (prototype).",
        mg.token_efficiency, py.token_efficiency, mg.reliability, rust.reliability
    );
    println!(
        "  • The advantage is real on the axes SWE cares about (reliability/determinism/safety),\n    \
         NOT on tokens — and it is a young prototype vs battle-tested Rust on correctness maturity."
    );
}

examples/swe_lang_profiles.rs (line 63)

fn main() {
    println!("=== Extensive agentic-SWE language comparison (sensitivity analysis) ===\n");

    let langs = real_languages();
    let ideal = profile(Language::Ideal);

    // ── Per-axis champions ────────────────────────────────────────────────────
    println!("PER-AXIS CHAMPIONS (best implemented language on each axis)");
    let axes: [(&str, fn(&LanguageProfile) -> f64); 4] = [
        ("token", |p| p.token_efficiency),
        ("determinism", |p| p.determinism),
        ("reliability", |p| p.reliability),
        ("safety", |p| p.safety),
    ];
    for (name, f) in axes {
        let best = langs.iter().max_by(|a, b| f(a).partial_cmp(&f(b)).unwrap()).unwrap();
        println!("  {name:<12} {} ({:.2})   [ideal ceiling {:.2}]", best.language.name(), f(best), f(&ideal));
    }

    // ── Ranking under each SWE scenario + rank matrix ─────────────────────────
    println!("\nRANKING BY SWE SCENARIO (implemented languages; score, and MechGen's rank)");
    let mut rank_of: std::collections::HashMap<&str, Vec<usize>> = std::collections::HashMap::new();
    let mut top3_count: std::collections::HashMap<&str, usize> = std::collections::HashMap::new();
    for prof in PROFILES {
        let mut ranked: Vec<&LanguageProfile> = langs.iter().collect();
        ranked.sort_by(|a, b| score(b, &prof.w).partial_cmp(&score(a, &prof.w)).unwrap());
        let order: Vec<String> = ranked.iter().map(|p| format!("{}({:.3})", p.language.name(), score(p, &prof.w))).collect();
        let mg_rank = ranked.iter().position(|p| p.language == Language::MechGen).unwrap() + 1;
        for (i, p) in ranked.iter().enumerate() {
            rank_of.entry(p.language.name()).or_default().push(i + 1);
            if i < 3 {
                *top3_count.entry(p.language.name()).or_default() += 1;
            }
        }
        println!("\n  [{}] {}", prof.name, prof.why);
        println!("    {}", order[..order.len().min(5)].join("  >  "));
        println!("    … MechGen #{mg_rank} of {}", langs.len());
    }

    // ── Robustness: how often each language lands top-3 across the 5 scenarios ─
    println!("\nROBUSTNESS (top-3 finishes across all {} scenarios; best/worst rank)", PROFILES.len());
    let mut summary: Vec<(&str, usize, usize, usize)> = top3_count
        .keys()
        .map(|&name| {
            let ranks = &rank_of[name];
            (name, top3_count[name], *ranks.iter().min().unwrap(), *ranks.iter().max().unwrap())
        })
        .collect();
    // include languages that never hit top-3
    for p in &langs {
        let n = p.language.name();
        if !top3_count.contains_key(n) {
            let ranks = &rank_of[n];
            summary.push((n, 0, *ranks.iter().min().unwrap(), *ranks.iter().max().unwrap()));
        }
    }
    summary.sort_by(|a, b| b.1.cmp(&a.1).then(a.2.cmp(&b.2)));
    for (name, t3, best, worst) in &summary {
        println!("  {name:<12} top-3 in {t3}/{}   rank range #{best}–#{worst}", PROFILES.len());
    }

    // ── Gap to the design-target ceiling (canonical fitness) ──────────────────
    println!("\nGAP TO THE `ideal` CEILING (canonical unweighted fitness)");
    let mut byfit: Vec<&LanguageProfile> = langs.iter().collect();
    byfit.sort_by(|a, b| b.fitness().partial_cmp(&a.fitness()).unwrap());
    for p in &byfit {
        println!("  {:<12} {:.3}   (−{:.3} from ideal {:.3})", p.language.name(), p.fitness(), ideal.fitness() - p.fitness(), ideal.fitness());
    }

    // ── Crossover: how token-obsessed must a weighting be to dethrone MechGen? ─
    // Score model: wt·token + (1−wt)/3·(determinism+reliability+safety). Solve for
    // the token weight wt where the terse champion ties MechGen.
    let mg = profile(Language::MechGen);
    let mg_other = (mg.determinism + mg.reliability + mg.safety) / 3.0;
    let crossover = |b: &LanguageProfile| -> f64 {
        let bo = (b.determinism + b.reliability + b.safety) / 3.0;
        // wt = (bo − mg_other) / (mg.token − mg_other − b.token + bo)
        (bo - mg_other) / (mg.token_efficiency - mg_other - b.token_efficiency + bo)
    };
    let bash = profile(Language::Bash);
    let py = profile(Language::Python);
    println!("\nCROSSOVER (token-weight at which a terse language overtakes MechGen)");
    println!("  vs bash (token {:.2}):   {:.0}% token weight", bash.token_efficiency, crossover(&bash) * 100.0);
    println!("  vs python (token {:.2}): {:.0}% token weight", py.token_efficiency, crossover(&py) * 100.0);
    println!("  → no realistic SWE weighting (token ≤ 40%) flips it; the crossover above (now even");
    println!("    higher, since the landed inference made MechGen's token axis competitive) needs");
    println!("    near-pure code-golf that ignores correctness for a terse language to win.");

    // ── Honest reading ────────────────────────────────────────────────────────
    println!("\nREADING (honest — MechGen is the project's own language):");
    println!("  • MechGen ranks #1 under ALL FIVE realistic SWE scenarios — including the");
    println!("    token-leaning rapid-prototyping one — because its reliability/determinism/safety");
    println!("    lead is large enough that realistic token weighting cannot overcome it.");
    println!("  • This is robust, not a one-weighting artifact: it never owns the `token` axis");
    println!("    (Bash does), yet it tops every scenario; only a ~70%-token weighting (above)");
    println!("    that essentially ignores correctness would favor terse languages — its token FLOOR.");
    println!("  • Bias guards hold (token ≤ Python, reliability ≤ Rust, no axis ≥ 0.98); scores were");
    println!("    corrected DOWN twice. The only thing above it is the unreachable `ideal` design target,");
    println!("    and it loses reliability head-to-head to battle-tested Rust (0.94 vs 0.95).");
}

pub fn from_name(name: &str) -> Option<Language>

Parse a (case-insensitive) name; accepts common aliases (js, ts, c++, sh, golang, py).

Trait Implementations

impl Clone for Language

fn clone(&self) -> Language

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Language

impl Debug for Language

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Language

impl Hash for Language

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Language

fn eq(&self, other: &Language) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Language

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Language