Enum BindError 

pub enum BindError {
    ClosureProvedAgainstAnotherPlan {
        planned: PlanId,
        proved: PlanId,
    },
    ExplanationAnsweredOverAnotherPlan {
        planned: PlanId,
        answered: PlanId,
    },
    ExplanationAnsweredOverAnotherClosure {
        proved: ClosureId,
        answered: ClosureId,
    },
}

How binding one expansion refuses.

Three values produced separately can disagree about their parentage in exactly three places, and each of the three is a different repair. Every arm names both identities it holds and elects neither.

Variants

ClosureProvedAgainstAnotherPlan

The closure proves a rendering against a plan other than the one handed in beside it.

Fields

planned: PlanId

The plan handed to the binding.

proved: PlanId

The plan the closure was actually proved against.

ExplanationAnsweredOverAnotherPlan

The explanation was answered over a plan other than the one handed in beside it.

Reachable under one kind, which is why the type parameter cannot catch it: two plans of one kind admit the same questions, so an explanation written over the other one covers its roster exactly.

Fields

planned: PlanId

The plan handed to the binding.

answered: PlanId

The plan the explanation was actually answered over.

ExplanationAnsweredOverAnotherClosure

The explanation was answered over a proof other than the one handed in beside it.

Reachable on its own, because one plan may be proved by two renderings and an explanation over the other proof states a digest of bytes this expansion never emitted.

Fields

proved: ClosureId

The proof handed to the binding.

answered: ClosureId

The proof the explanation was actually answered over.

Implementations

impl BindError

pub fn canonical_bytes(&self) -> Vec<u8>

This disagreement’s complete canonical material: which pair disagreed, then the identity that was BOUND and the identity the value handed in turned out to name, each at full width.

The pair’s position leads, so two pairs holding identities that happened to coincide still derive two related identities. The bound identity rides ahead of the carried one, so a reader of the two knows which is which without the diagnostic saying so twice.

impl BindError

pub const fn slot(&self) -> u8

This pair’s position in the declared roster, written ahead of the two identities it disagreed over.

Appended and never renumbered: the byte stands inside every related identity derived over a binding refusal.

Trait Implementations

impl Clone for BindError

fn clone(&self) -> BindError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BindError

impl Debug for BindError

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

Formats the value using the given formatter.

impl Display for BindError

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

Formats the value using the given formatter.

impl Eq for BindError

impl Error for BindError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl Hash for BindError

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BindError

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

Equality operator ==.

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

Inequality operator !=.

impl Refused for BindError

fn observed(&self) -> Observed

Every pair is two identities that had to match and did not.

fn body(&self) -> LineBody

One disagreement, always.

The binding compares each pair in turn and refuses at the first that disagrees, so there is no body behind the cause and nothing for a line to count.

fn related(&self) -> Vec<Vec<u8>>

A single cause enumerates nothing: the primary cause is the summary’s own subject, never a member of its related set.

fn repairs(&self) -> Bounded<Repair, REPAIR_LIMIT>

The one repair, citing this home’s own declared fact.

Unlike a refusal about what a caller declared, the law here is this compiler’s, so the fact is this home’s to cite.

const PHASE: Phase = Phase::Binding

The step of the road this refusal is raised at.

const FAMILY: Family = BINDING_FAMILY

The family whose issue space this refusal’s related identities derive in.

fn class(&self) -> RefusalClass

Which class of refusal the summary line opens with.

fn first(&self) -> String

How the first established issue reads for a person.

impl StructuralPartialEq for BindError