Struct Rejection 

pub struct Rejection {
    pub code: String,
    pub error: String,
    pub expected: Option<String>,
    pub actual: Option<String>,
    pub next: String,
}

A refusal, with enough for a client to decide what to do next.

Fields

code: String

Stable machine-readable reason.

error: String

Human-readable detail. Kept named error because that is what every existing client and test already reads.

expected: Option<String>

What the check required, when the check compared two states.

actual: Option<String>

What it found instead.

next: String

The admissible next action, in the imperative. This is the field the research isolates the gain to, so it is required rather than optional: a rejection that cannot name a next action is a rejection whose author has not finished thinking.

Implementations

impl Rejection

pub fn new( code: Code, error: impl Into<String>, next: impl Into<String>, ) -> Self

A rejection with no state comparison.

pub fn with_states( self, expected: Option<String>, actual: Option<String>, ) -> Self

Adds the two states a failed comparison was between.

pub fn to_json(&self) -> Value

This rejection as a JSON value.

pub fn encode(&self) -> String

Renders for the Result<(), String> seam.

pub fn decode(reason: &str) -> Self

Recovers a rejection from a reason string.

A reason that did not come from Rejection::encode becomes an Code::Unclassified rejection carrying the original text, so a caller always gets the same shape and no message is ever dropped on the floor.

pub fn body(&self) -> String

The HTTP body: the rejection as JSON.

Trait Implementations

impl Clone for Rejection

fn clone(&self) -> Rejection

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rejection

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

Formats the value using the given formatter.

impl PartialEq for Rejection

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

impl StructuralPartialEq for Rejection