Enum Judgement 

pub enum Judgement {
    Established,
    NotEstablished {
        reason: String,
    },
    NotAsked,
    Unobservable {
        reason: String,
    },
}

One question’s judgement — the four-pole core every tool verdict maps onto (RFC 13, v1.24; RFC 09 §5.1 pre-v1.24). See the module doc.

Variants

Established

Established(yes): the question was put and the claim holds — positive evidence, conclusive.

NotEstablished

Established(no): the question was put and the claim conclusively does not hold — with the reason, which is where the honesty lives.

Fields

reason: String

NotAsked

Unestablished: the question was not put — the input was not fetched, was not requested, or does not exist for this subject. Not asked is not answered no (RFC 09 §5.1 O4).

Unobservable

Unestablished: the question was put and the observation cannot carry the claim — a drop under a completeness claim, a window shorter than the claim’s span, or an ask that failed (RFC 09 §5.1 O6).

Fields

reason: String

Implementations

impl Judgement

pub fn conclusive(&self) -> Option<bool>

Whether the question reached a conclusive answer: Some(true) = Established(yes), Some(false) = Established(no), None = neither pole of Unestablished says anything.

pub fn is_unobservable(&self) -> bool

The observation was made and could not carry the claim.

pub fn is_not_asked(&self) -> bool

The question was never put.

Trait Implementations

impl Clone for Judgement

fn clone(&self) -> Judgement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Judgement

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

Formats the value using the given formatter.

impl Eq for Judgement

impl From<&Judgement> for CondState

The documented wire projection (RFC 13, v1.24): Established → firing, NotEstablished → ok (the polarity note on CondState), both unestablished poles → unobservable.

fn from(j: &Judgement) -> CondState

Converts to this type from the input type.

impl From<Judgement> for CondState

fn from(j: Judgement) -> CondState

Converts to this type from the input type.

impl From<Judgement> for CutoverVerdict

The inverse of CutoverVerdict::to_judgement. Both unestablished poles fold to Unproven: a question that was not put (or could not be carried) proves no migration.

fn from(j: Judgement) -> CutoverVerdict

Converts to this type from the input type.

impl From<Judgement> for ExpectVerdict

The inverse of ExpectVerdict::to_judgement — what lets expect fold a judge’s answer straight into its verdict without hand-mapping. Both unestablished poles are Impaired: an assertion that was not (or could not be) observed is not met and not violated.

fn from(j: Judgement) -> ExpectVerdict

Converts to this type from the input type.

impl From<Judgement> for WhyVerdict

The inverse of WhyVerdict::to_judgement, same (inverted) polarity: an established finding is Explained, established-clean is Healthy, and both unestablished poles fold to Impaired — a ladder nobody asked is exactly a ladder that cannot claim health.

fn from(j: Judgement) -> WhyVerdict

Converts to this type from the input type.

impl PartialEq for Judgement

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Judgement

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 Judgement