Struct AveragedGroup 

#[non_exhaustive]
pub struct AveragedGroup {
    pub row: GauntletRow,
    pub passes_observed: u32,
    pub skips_observed: u32,
    pub inconclusives_observed: u32,
    pub failures_observed: u32,
    pub total_observed: u32,
}

Re-export of the comparison-policy types so downstream crates using ktstr::cli as their public surface don’t need to reach into the internal ktstr::stats module (which is pub(crate) — see lib.rs — and therefore not a stable public path). The policy is the only item in stats that a CLI or external consumer constructs directly; every other item is internal plumbing reached via cli::compare_partitions. One aggregated GauntletRow produced by group_and_average_by, plus the pass-bookkeeping needed to render the per-group summary block (N/M passed + the (S skip, I inc, F fail) breakdown).

row carries arithmetic-mean metric values across every real Pass contributor in the group; the (scenario, topology, work_type, scheduler, kernel_version) identity is taken verbatim from the first contributor in iteration order — every contributor in the group shares the identity tuple by construction (scenario, topology, and work_type ARE the group key, and scheduler / kernel_version are typed-filter-narrowed at the call site so they can only vary if the operator passed no --scheduler / --kernel filter).

The verdict bits on row (passed, skipped, inconclusive) fold under the strict 4-state Fail > Inconclusive > Pass > Skip lattice: any failing contributor sets the aggregate to Fail (passed=false, inconclusive=false, skipped=false); else any inconclusive contributor sets inconclusive=true; else any skipped contributor sets skipped=true; only an all-pass cohort yields passed=true. The lattice mechanics match GauntletRow::is_pass’s triple-conjunct, so the aggregated row’s accessor reads honestly. Aggregate rows that are not real Pass route the pair through compare_rows_by’s excluded_pairs gate.

passes_observed, skips_observed, inconclusives_observed, failures_observed and total_observed count contributors per the strict 4-state mutex: the four bucket counters sum to total_observed because every contributor falls into exactly one bucket. Only real Pass contributors feed the per-row sums — failing, inconclusive, and skipped contributors all carry no comparable per-run signal (failure-mode telemetry; “couldn’t evaluate” non-signal; “didn’t run” non-signal). When no contributor passed cleanly the running sum is zero and the aggregate row carries default-zero metric values plus passed = false — the downstream excluded_pairs gate then drops the pair from the regression math.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

row: GauntletRow

Aggregated row carrying arithmetic-mean metric values plus the lattice-folded (passed, skipped, inconclusive) bits matching the Fail > Inconclusive > Pass > Skip dominance. passed is true only when every contributor was a real pass; inconclusive fires when at least one contributor was Inconclusive and none failed; skipped fires when at least one contributor was Skip and none failed or was Inconclusive. Fed directly into compare_rows (averaging is the fixed compare_partitions fold).

passes_observed: u32

Number of contributors that were a real pass (is_pass() == true). Renders as the numerator of the per-group N/M summary.

skips_observed: u32

Number of contributors that were Skip (is_skip() == true). Surfaced in the per-group rendering as the “S skipped” breakdown so an operator can distinguish “scenario didn’t run” from real failures.

inconclusives_observed: u32

Number of contributors that were Inconclusive (is_inconclusive() == true). Surfaced in the per-group rendering as the “I inconclusive” breakdown so an operator can distinguish “couldn’t evaluate” from real failures — same defense-in-depth pattern as format_dimension_summary’s inconc bucket.

failures_observed: u32

Number of contributors that were a real Fail (is_fail() == true). Surfaced in the per-group rendering as the “F failed” breakdown.

total_observed: u32

Total contributors in the group (= group.len()). Renders as the denominator of the per-group N/M summary. Mechanically: total_observed == passes_observed + skips_observed + inconclusives_observed + failures_observed under the strict 4-state mutex.

Trait Implementations

impl Clone for AveragedGroup

fn clone(&self) -> AveragedGroup

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AveragedGroup

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

Formats the value using the given formatter.