Struct ReasoningEvidence 

pub struct ReasoningEvidence {
    pub kind: ReasoningEvidenceKind,
    pub reference: String,
    pub note: Option<String>,
}

A reference to something that supports a claim.

Evidence is a pointer, never a copy: a path, a case, an id or a command line, with an optional one-line note of what it shows. Unknown fields are refused, so a misspelt field is an error rather than a silently dropped claim.

use majordomus_cli::reasoning::record::{ReasoningEvidence, ReasoningEvidenceKind};

let e: ReasoningEvidence = serde_json::from_value(serde_json::json!({
    "kind": "file",
    "reference": "src/worker.rs:42",
}))
.unwrap();
assert_eq!(e.kind, ReasoningEvidenceKind::File);
assert_eq!(e.note, None);

let typo = serde_json::from_value::<ReasoningEvidence>(serde_json::json!({
    "kind": "file", "reference": "x", "notes": "misspelt",
}));
assert!(typo.is_err());

Fields

kind: ReasoningEvidenceKind

What it is.

reference: String

Where it is: a path, a case, an id, a command line.

note: Option<String>

What it shows, in one line.

Trait Implementations

impl Clone for ReasoningEvidence

fn clone(&self) -> ReasoningEvidence

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReasoningEvidence

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReasoningEvidence

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ReasoningEvidence

impl JsonSchema for ReasoningEvidence

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for ReasoningEvidence

fn eq(&self, other: &ReasoningEvidence) -> 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 ReasoningEvidence

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 ReasoningEvidence