Enum Error 

pub enum Error {
    UnexpectedDType {
        msg: &'static str,
        expected: DType,
        got: DType,
    },
    DTypeMismatchBinaryOp {
        lhs: DType,
        rhs: DType,
        op: &'static str,
    },
    UnsupportedDTypeForOp(DType, &'static str),
    NoZeroScalar(DType),
    NoOneScalar(DType),
    ScalarUnrepresentable(DType, f64),
    PackedElementHasNoScalar(DType),
    DimOutOfRange {
        shape: Box<Shape>,
        dim: i32,
        op: &'static str,
    },
    DuplicateDimIndex {
        shape: Box<Shape>,
        dims: Vec<usize>,
        op: &'static str,
    },
    UnexpectedNumberOfDims {
        expected: usize,
        got: usize,
        shape: Box<Shape>,
    },
    UnexpectedShape {
        msg: String,
        expected: Box<Shape>,
        got: Box<Shape>,
    },
    ShapeMismatch {
        buffer_size: usize,
        shape: Box<Shape>,
    },
    ShapeMismatchBinaryOp {
        lhs: Box<Shape>,
        rhs: Box<Shape>,
        op: &'static str,
    },
    ShapeMismatchCat {
        dim: usize,
        first_shape: Box<Shape>,
        n: usize,
        nth_shape: Box<Shape>,
    },
    ShapeMismatchSplit {
        shape: Box<Shape>,
        dim: usize,
        n_parts: usize,
    },
    OnlySingleDimension {
        op: &'static str,
        dims: Vec<usize>,
    },
    EmptyTensor {
        op: &'static str,
    },
    DeviceMismatchBinaryOp {
        lhs: DeviceLocation,
        rhs: DeviceLocation,
        op: &'static str,
    },
    NarrowInvalidArgs {
        shape: Box<Shape>,
        dim: usize,
        start: usize,
        len: usize,
        msg: &'static str,
    },
    Conv1dInvalidArgs {
        inp_shape: Box<Shape>,
        k_shape: Box<Shape>,
        padding: usize,
        stride: usize,
        msg: &'static str,
    },
    InvalidIndex {
        op: &'static str,
        index: usize,
        size: usize,
    },
    BroadcastIncompatibleShapes {
        src_shape: Box<Shape>,
        dst_shape: Box<Shape>,
    },
    CannotSetVar {
        msg: &'static str,
    },
    MatMulUnexpectedStriding(Box<MatMulUnexpectedStriding>),
    RequiresContiguous {
        op: &'static str,
    },
    OpRequiresAtLeastOneTensor {
        op: &'static str,
    },
    OpRequiresAtLeastTwoTensors {
        op: &'static str,
    },
    BackwardNotSupported {
        op: &'static str,
    },
    NoBackendForOp {
        op: OpKind,
        dtypes: Vec<DType>,
        available_backends: Vec<BackendId>,
        supported_combinations: Vec<(BackendId, OpKind, Vec<DType>)>,
    },
    UnsupportedTransfer {
        from: DeviceLocation,
        to: DeviceLocation,
        available_paths: Vec<TransferPath>,
    },
    AlignmentMismatch {
        backend: BackendId,
        required: usize,
        actual: usize,
    },
    TopologyChanged {
        plan_generation: u64,
        current_generation: u64,
    },
    NotCompiledWithCudaSupport,
    NotCompiledWithMetalSupport,
    NotCompiledWithVulkanSupport,
    CannotFindTensor {
        path: String,
    },
    Cuda(Box<dyn Error + Send + Sync>),
    Metal(Box<dyn Error + Send + Sync>),
    Vulkan(Box<dyn Error + Send + Sync>),
    TryFromIntError(TryFromIntError),
    Npy(String),
    Zip(ZipError),
    ParseInt(ParseIntError),
    FromUtf8(FromUtf8Error),
    Io(Error),
    SafeTensor(SafeTensorError),
    UnsupportedSafeTensorDtype(Dtype),
    Wrapped(Box<dyn Display + Send + Sync>),
    WrappedContext {
        wrapped: Box<dyn Error + Send + Sync>,
        context: String,
    },
    Context {
        inner: Box<Error>,
        context: Box<dyn Display + Send + Sync>,
    },
    WithPath {
        inner: Box<Error>,
        path: PathBuf,
    },
    WithBacktrace {
        inner: Box<Error>,
        backtrace: Box<Backtrace>,
    },
    Msg(String),
    UnwrapNone,
    FilterRejected {
        filter: &'static str,
        ctx_summary: String,
        available_alternatives: usize,
    },
    InvalidBranch {
        reason: String,
    },
}

The main error type for the fuel library.

Variants

UnexpectedDType

Fields

msg: &'static str

expected: DType

got: DType

DTypeMismatchBinaryOp

Fields

lhs: DType

rhs: DType

op: &'static str

UnsupportedDTypeForOp(DType, &'static str)

NoZeroScalar(DType)

NoOneScalar(DType)

ScalarUnrepresentable(DType, f64)

PackedElementHasNoScalar(DType)

DimOutOfRange

Fields

shape: Box<Shape>

dim: i32

op: &'static str

DuplicateDimIndex

Fields

shape: Box<Shape>

dims: Vec<usize>

op: &'static str

UnexpectedNumberOfDims

Fields

expected: usize

got: usize

shape: Box<Shape>

UnexpectedShape

Fields

msg: String

expected: Box<Shape>

got: Box<Shape>

ShapeMismatch

Fields

buffer_size: usize

shape: Box<Shape>

ShapeMismatchBinaryOp

Fields

lhs: Box<Shape>

rhs: Box<Shape>

op: &'static str

ShapeMismatchCat

Fields

dim: usize

first_shape: Box<Shape>

n: usize

nth_shape: Box<Shape>

ShapeMismatchSplit

Fields

shape: Box<Shape>

dim: usize

n_parts: usize

OnlySingleDimension

Fields

op: &'static str

dims: Vec<usize>

EmptyTensor

Fields

op: &'static str

DeviceMismatchBinaryOp

Fields

lhs: DeviceLocation

rhs: DeviceLocation

op: &'static str

NarrowInvalidArgs

Fields

shape: Box<Shape>

dim: usize

start: usize

len: usize

msg: &'static str

Conv1dInvalidArgs

Fields

inp_shape: Box<Shape>

k_shape: Box<Shape>

padding: usize

stride: usize

msg: &'static str

InvalidIndex

Fields

op: &'static str

index: usize

size: usize

BroadcastIncompatibleShapes

Fields

src_shape: Box<Shape>

dst_shape: Box<Shape>

CannotSetVar

Fields

msg: &'static str

MatMulUnexpectedStriding(Box<MatMulUnexpectedStriding>)

RequiresContiguous

Fields

op: &'static str

OpRequiresAtLeastOneTensor

Fields

op: &'static str

OpRequiresAtLeastTwoTensors

Fields

op: &'static str

BackwardNotSupported

Fields

op: &'static str

NoBackendForOp

No registered backend supports (op, dtypes) for the given input residency. Fires at DAG construction (planning time), not at execution.

dtypes is the per-operand dtype list (inputs in order, then outputs) used as the binding-table lookup key. For uniform- precision ops the list contains a single repeated dtype; for mixed-precision ops (e.g. Cast: src→dst) the list distinguishes the operands.

Fields

op: OpKind

dtypes: Vec<DType>

available_backends: Vec<BackendId>

supported_combinations: Vec<(BackendId, OpKind, Vec<DType>)>

UnsupportedTransfer

No transfer path connects from and to directly, and host-staging fallback isn’t available either (e.g. neither device can copy_to_host). Fires at DAG construction.

Fields

from: DeviceLocation

to: DeviceLocation

available_paths: Vec<TransferPath>

AlignmentMismatch

Source storage’s alignment doesn’t meet the destination backend’s required alignment, and Router has no way to repack on this path. Fires at DAG construction.

Fields

backend: BackendId

required: usize

actual: usize

TopologyChanged

The ExecutionPlan consumed by the executor was built against an older SystemTopology generation than the one observable at dispatch time — backends were added, removed, or had their capabilities re-probed since the plan was committed. Caught at dispatch-chunk boundaries by Phase 4.3 of the picker-work arc; the realize layer catches this and rebuilds the plan against the fresh topology.

plan_generation is the counter the plan was stamped with at compile_plan time. current_generation is the value fuel_dispatch::dispatch::topology_generation() observed when the executor crossed the chunk boundary.

Fields

plan_generation: u64

current_generation: u64

NotCompiledWithCudaSupport

NotCompiledWithMetalSupport

NotCompiledWithVulkanSupport

CannotFindTensor

Fields

path: String

Cuda(Box<dyn Error + Send + Sync>)

Metal(Box<dyn Error + Send + Sync>)

Vulkan(Box<dyn Error + Send + Sync>)

TryFromIntError(TryFromIntError)

Npy(String)

Zip(ZipError)

Zip file format error.

ParseInt(ParseIntError)

Integer parse error.

FromUtf8(FromUtf8Error)

Utf8 parse error.

Io(Error)

I/O error.

SafeTensor(SafeTensorError)

SafeTensor error.

UnsupportedSafeTensorDtype(Dtype)

Wrapped(Box<dyn Display + Send + Sync>)

Arbitrary errors wrapping.

WrappedContext

Arbitrary errors wrapping with context.

Fields

wrapped: Box<dyn Error + Send + Sync>

context: String

Context

Fields

inner: Box<Error>

context: Box<dyn Display + Send + Sync>

WithPath

Adding path information to an error.

Fields

inner: Box<Error>

path: PathBuf

WithBacktrace

Fields

inner: Box<Error>

backtrace: Box<Backtrace>

Msg(String)

User generated error message, typically created via bail!.

UnwrapNone

FilterRejected

A hard filter in the optimizer ranker’s filter chain rejected every candidate at this decision point. Phase 1.1 of the picker-work arc. The user asked for something the binding-table can’t deliver — typically a precision floor or tolerance budget no registered kernel meets — and the ranker surfaces it rather than silently substituting a non-admissible alternative.

Soft filters (caps preferences, empirical refinements) never raise this error; only filters classified FilterClass::Hard fail loudly when they would leave the candidate set empty.

Fields

filter: &'static str

Name of the filter that triggered the rejection.

ctx_summary: String

Short diagnostic summary of the decision point’s context (op kind, dtypes, device).

available_alternatives: usize

How many candidates entered the filter (zero on the way in is also possible — the candidate enumerator may have produced an empty set).

InvalidBranch

Build-time rejection from the Op::Branch builders (Graph::open_branch / BranchBuilder::add_arm / BranchBuilder::finalize_branches). Phase A PR-A1 of the “plan IS the graph” rebuild. The multi-path structure is an arena fact validated at graph-build time — never a realize-time panic — so an ill-formed branch (a reconverge_at that is not a descendant of the diverge point, arms that are not internally disjoint, arm exits that disagree on shape/dtype at reconverge) surfaces here with a human-readable reason rather than corrupting the arena.

Fields

reason: String

Why the branch was rejected — names the violated invariant and the offending node ids for localization.

Implementations

impl Error

pub fn wrap(err: impl Display + Send + Sync + 'static) -> Error

Wraps an arbitrary displayable error.

pub fn msg(err: impl Display) -> Error

Creates an error message from any displayable value.

pub fn debug(err: impl Debug) -> Error

Creates an error message from the debug representation of a value.

pub fn cuda(err: impl Error + Send + Sync + 'static) -> Error

Wraps a CUDA backend error.

pub fn metal(err: impl Error + Send + Sync + 'static) -> Error

Wraps a Metal backend error.

pub fn vulkan(err: impl Error + Send + Sync + 'static) -> Error

Wraps a Vulkan backend error.

pub fn bt(self) -> Error

Captures a backtrace and attaches it to this error.

pub fn with_path<P>(self, p: P) -> Error

where P: AsRef<Path>,

Attaches a filesystem path to this error for better diagnostics.

pub fn context(self, c: impl Display + Send + Sync + 'static) -> Error

Wraps this error with additional context.

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

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.

impl From<Error> for Error

fn from(source: Error) -> Error

Converts to this type from the input type.

impl From<FromUtf8Error> for Error

fn from(source: FromUtf8Error) -> Error

Converts to this type from the input type.

impl From<Object> for Error

fn from(value: Object) -> Error

Converts to this type from the input type.

impl From<ParseIntError> for Error

fn from(source: ParseIntError) -> Error

Converts to this type from the input type.

impl From<SafeTensorError> for Error

fn from(source: SafeTensorError) -> Error

Converts to this type from the input type.

impl From<TryFromIntError> for Error

fn from(source: TryFromIntError) -> Error

Converts to this type from the input type.

impl From<ZipError> for Error

fn from(source: ZipError) -> Error

Converts to this type from the input type.