Struct Explanation 

pub struct Explanation {
    pub uri: String,
    pub standing: Standing,
    pub detail: String,
    pub entry: Option<ContextEntry>,
    pub excluded: Option<Excluded>,
    pub deduplicated: Option<Deduplicated>,
    pub budget: Budget,
}

Why one identifier is, or is not, in a compiled context.

standing says which of the five cases this is, and the three optional fields are the evidence for it: at most one of entry, excluded and deduplicated is populated, and which one is determined by the standing rather than independent of it. detail is the same answer in words, so the value is legible without a reader matching them up.

budget is always present, including when the answer is unknown, and that is the point of carrying it: the commonest reason to ask this question is an entry that did not fit, and an explanation that said “excluded for budget” without the budget would need a second call to act on.

use majordomus_cli::devcontext::{compile, explain, CompileInput, ExplainInput};
use majordomus_cli::devcontext::{Explanation, Standing};
use majordomus_cli::synthetic::SyntheticRepository;

let repo = SyntheticRepository::small().unwrap();
let ctx = repo.context().unwrap();
let compiled = compile(&ctx, CompileInput::default()).unwrap();
let selected = compiled.selected[0].uri.clone();

// something in the answer: the entry is the evidence, and the other two are empty
let e: Explanation =
    explain(&ctx, ExplainInput { uri: selected.clone(), ..Default::default() }).unwrap();
assert_eq!(e.standing, Standing::Selected);
assert_eq!(e.entry.as_ref().unwrap().uri, selected);
assert!(e.excluded.is_none() && e.deduplicated.is_none());
assert!(!e.detail.is_empty(), "the standing always reads as a sentence too");

// something this repository does not hold: an answer, not an error — and the budget
// the judgement was made under is carried even here
let absent: Explanation = explain(
    &ctx,
    ExplainInput { uri: "majordomus://adr/9999".into(), ..Default::default() },
)
.unwrap();
assert_eq!(absent.standing, Standing::Unknown);
assert!(absent.entry.is_none());
assert_eq!(absent.budget.limit_tokens, compiled.budget.limit_tokens);

Fields

uri: String

What was asked about.

standing: Standing

Where it stands.

detail: String

The same, in words.

entry: Option<ContextEntry>

The entry, when it is in the answer.

excluded: Option<Excluded>

The exclusion, when it was reached and not given.

deduplicated: Option<Deduplicated>

The collapse it was part of, when it was folded or dropped for another.

budget: Budget

The budget the judgement was made under, so that “excluded for budget” can be acted on without a second call.

Trait Implementations

impl Clone for Explanation

fn clone(&self) -> Explanation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Explanation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Explanation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Explanation

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 Explanation

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

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 Explanation