Struct P4 

pub struct P4 {

    pub verdict: Verdict,
    pub why: String,
    pub cases: usize,
    pub of: usize,
    pub runs: usize,
    pub checks: usize,
    pub seeds: (usize, usize),
    pub usd: f64,
    pub applying: usize,
    pub fit: String,
    pub labels: u32,
    pub baseline: Option<Arm>,
    pub p4a: Option<Part>,
    pub p4b: Option<Part>,
    pub p4c: Option<Part>,
}

Fields

verdict: Verdict

why: String

cases: usize

Cases with runs, of the cases the qrels name; runs and graded checks read.

of: usize

runs: usize

checks: usize

seeds: (usize, usize)

Fewest and most runs (seeds) per case.

usd: f64

What a check’s model call cost, on average: the same call under every policy.

applying: usize

Of the checks, those that apply a lesson: P4a tests nothing without one, as every policy decides nothing there.

fit: String

The store’s posterior P4b draws from (select/policy.rs Fit::key, empty for the prior) and the labels it read.

labels: u32

baseline: Option<Arm>

p4a: Option<Part>

P4a, P4b and P4c (module doc); None until the evaluation is complete. verdict is theirs by the rules v2’s default rule: PASS when P4a and P4c pass and P4b passes or is NOT TESTED, FAIL when one of them fails, NOT TESTED otherwise.

p4b: Option<Part>

p4c: Option<Part>

Trait Implementations

impl Clone for P4

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for P4

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

Formats the value using the given formatter.

impl PartialEq for P4

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for P4

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 P4