Struct Error 

pub struct Error {
    pub kind: Kind,
    pub message: String,
    /* private fields */
}

A raised exception, on its way out of the runtime.

Not the same thing as an Exception, which is the object a program holds. This is the Rust error the ? in every operation propagates, and it is a kind and a message because that is all a division by zero has: no Python object is made for one unless something asks for it.

Fields

kind: Kind

Which one it is.

message: String

What it says, which is empty for the ones that say nothing.

Implementations

impl Error

pub fn new(kind: Kind, message: impl Into<String>) -> Self

An exception of this kind with this message.

pub fn type_error(message: impl Into<String>) -> Self

The wrong type for the operation.

pub fn value_error(message: impl Into<String>) -> Self

The right type and the wrong value.

pub fn zero_division(message: impl Into<String>) -> Self

A divisor that was zero.

pub fn overflow(message: impl Into<String>) -> Self

A result that will not fit.

pub fn raised(kind: Kind, args: Vec<Object>) -> Self

An exception built from the arguments a program would have written.

The message comes out of the arguments rather than being given separately, so an exception the runtime raises this way is the one a handler catches: {}['k'] raises a KeyError whose args really is ('k',) and not a KeyError holding the string 'k' with its quotes already in it.

pub fn with_value(self, value: Object) -> Self

The same exception, carrying the object a program raised.

Carried rather than rebuilt at the catch, because raise e and the except ... as e that catches it have to be the same object and there is no way back to it from a kind and a message.

pub fn value(&self) -> Option<&Object>

The object that was raised, for a caller that has to hand back the very one. None when the runtime raised this itself.

pub fn instance(&self) -> Object

The exception as an object, which is what an except clause tests and what as binds.

The one a program raised when there is one, so that raise e and the except ... as e catching it are the same object. One built here otherwise, out of the message, because a division by zero never made an object and except ZeroDivisionError as e still has to have something to bind. Its arguments come out the way CPython’s do, which is one argument holding the sentence, or none when there is no sentence.

A Kind::KeyError is the one that cannot be rebuilt from its message, since its message is already the repr of its key. That is why every KeyError the runtime raises is built with Error::raised and carries its key.

Trait Implementations

impl Clone for Error

fn clone(&self) -> Error

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

The tail of a traceback: every exception that led to this one, oldest first, and then this one.

There are no File "x", line n lines in between because there is no line table yet, so what comes out is the part of a traceback that says what happened without the part that says where.

impl Error for Error

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.