Struct CandidateError 

pub struct CandidateError {
    pub failure: CandidateFailure,
    pub message: String,
}

What: One candidate failure: its cause and a complete explanation. String is a heap-allocated, growable UTF-8 buffer this struct owns. Sibling the reader might expect: &str, a borrowed view that owns nothing. Why: The error outlives the formatted text built at the failure site, so a borrowed &str would dangle. Messages never contain file content or pathnames: a pathname can itself be a forbidden string.

In TS you’d write (pseudocode):

class CandidateError extends Error { failure: CandidateFailure; message: string }

Fields

failure: CandidateFailure

Closed cause callers branch on.

message: String

Complete diagnostic naming the Git operation and what to check.

Implementations

impl CandidateError

What: impl CandidateError { ... } attaches functions to the struct, like class statics. Why: Failure sites keep their condition next to its user-facing explanation.

In TS you’d write (pseudocode):

new CandidateError(failure, message);

pub fn new(failure: CandidateFailure, message: &str) -> CandidateError

What: Build an error from a cause and borrowed text. &str lends the caller’s bytes; String::from copies them into storage the error owns. Why: Messages are usually format! temporaries that end with the caller’s statement.

In TS you’d write (pseudocode):

constructor(failure: CandidateFailure, message: string) { super(message); }

Trait Implementations

impl Clone for CandidateError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CandidateError

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

Formats the value using the given formatter.

impl Display for CandidateError

What: impl std::fmt::Display for CandidateError supplies Rust’s “print me” interface. :: walks module paths, like std.fmt.Display would in TS. Why: The executable writes the message with ordinary formatting, not field access.

In TS you’d write (pseudocode):

toString(): string { return this.message; }

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

What: &self borrows this error read-only; &mut lends the formatter for writing; '_ is an unnamed lifetime the compiler fills in. Why: Formatting writes into the caller’s buffer without allocating another string.

In TS you’d write (pseudocode):

format(out: Writer): void { out.write(this.message); }

impl Eq for CandidateError

impl Error for CandidateError

What: An empty impl marks the type as a standard error value. Why: Generic error handling can carry it without converting it to a bare string.

In TS you’d write (pseudocode):

// `extends Error` already provides this in TypeScript.

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 PartialEq for CandidateError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CandidateError