Enum TorshError 

pub enum TorshError {
    Shape(ShapeError),
    Index(IndexError),
    General(GeneralError),
    WithContext {
        message: String,
        error_category: ErrorCategory,
        severity: ErrorSeverity,
        debug_context: Box<ErrorDebugContext>,
        source: Option<Box<TorshError>>,
    },
    ShapeMismatch {
        expected: Vec<usize>,
        got: Vec<usize>,
    },
    BroadcastError {
        shape1: Vec<usize>,
        shape2: Vec<usize>,
    },
    IndexOutOfBounds {
        index: usize,
        size: usize,
    },
    InvalidArgument(String),
    IoError(String),
    DeviceMismatch,
    NotImplemented(String),
    SynchronizationError(String),
    AllocationError(String),
    InvalidOperation(String),
    ConversionError(String),
    BackendError(String),
    InvalidShape(String),
    RuntimeError(String),
    DeviceError(String),
    ConfigError(String),
    InvalidState(String),
    UnsupportedOperation {
        op: String,
        dtype: String,
    },
    AutogradError(String),
    ComputeError(String),
    SerializationError(String),
    IndexError {
        index: usize,
        size: usize,
    },
    InvalidDimension {
        dim: usize,
        ndim: usize,
    },
    IterationError(String),
    Other(String),
    Context {
        message: String,
    },
    InvalidDevice {
        device_id: usize,
    },
    Backend(String),
    InvalidValue(String),
    Memory {
        message: String,
    },
    CudnnError(String),
    Unimplemented(String),
    InitializationError(String),
}

Main ToRSh error enum - unified interface to all error types

Variants

Shape(ShapeError)

Index(IndexError)

General(GeneralError)

WithContext

Fields

message: String

error_category: ErrorCategory

severity: ErrorSeverity

debug_context: Box<ErrorDebugContext>

source: Option<Box<TorshError>>

ShapeMismatch

Fields

expected: Vec<usize>

got: Vec<usize>

BroadcastError

Fields

shape1: Vec<usize>

shape2: Vec<usize>

IndexOutOfBounds

Fields

index: usize

size: usize

InvalidArgument(String)

IoError(String)

DeviceMismatch

NotImplemented(String)

SynchronizationError(String)

AllocationError(String)

InvalidOperation(String)

ConversionError(String)

BackendError(String)

InvalidShape(String)

RuntimeError(String)

DeviceError(String)

ConfigError(String)

InvalidState(String)

UnsupportedOperation

Fields

op: String

dtype: String

AutogradError(String)

ComputeError(String)

SerializationError(String)

IndexError

Fields

index: usize

size: usize

InvalidDimension

Fields

dim: usize

ndim: usize

IterationError(String)

Other(String)

Context

Fields

message: String

InvalidDevice

Fields

device_id: usize

Backend(String)

InvalidValue(String)

Memory

Fields

message: String

CudnnError(String)

Unimplemented(String)

InitializationError(String)

Implementations

impl TorshError

pub fn shape_mismatch(expected: &[usize], got: &[usize]) -> TorshError

Create a shape mismatch error (backward compatibility)

pub fn dimension_error(msg: &str, operation: &str) -> TorshError

Create a dimension error during operation

pub fn index_error(index: usize, size: usize) -> TorshError

Create an index error

pub fn type_mismatch(expected: &str, actual: &str) -> TorshError

Create a type mismatch error

pub fn dimension_error_with_context(msg: &str, operation: &str) -> TorshError

Create a dimension error with context (backward compatibility)

pub fn synchronization_error(msg: &str) -> TorshError

Create a synchronization error (backward compatibility)

pub fn allocation_error(msg: &str) -> TorshError

Create an allocation error (backward compatibility)

pub fn invalid_operation(msg: &str) -> TorshError

Create an invalid operation error (backward compatibility)

pub fn conversion_error(msg: &str) -> TorshError

Create a conversion error (backward compatibility)

pub fn invalid_argument_with_context(msg: &str, context: &str) -> TorshError

Create an invalid argument error with context (backward compatibility)

pub fn config_error_with_context(msg: &str, context: &str) -> TorshError

Create a config error with context (backward compatibility)

pub fn dimension_error_simple(msg: String) -> TorshError

Create a dimension error (backward compatibility)

pub fn shape_mismatch_formatted(expected: &str, got: &str) -> TorshError

Create a formatted shape mismatch error (backward compatibility)

pub fn operation_error(msg: &str) -> TorshError

Create an operation error (backward compatibility)

pub fn wrap_with_location(self, location: String) -> TorshError

Wrap an error with location information (backward compatibility)

pub fn category(&self) -> ErrorCategory

Get the error category

pub fn severity(&self) -> ErrorSeverity

Get the error severity

pub fn with_context(self, message: &str) -> TorshError

Add minimal context to an error (lightweight, no backtrace)

Use this for performance-critical paths where error context is helpful but backtrace overhead is not justified.

Example

use torsh_core::error::{TorshError, Result};

fn tensor_operation() -> Result<()> {
    let error = TorshError::InvalidShape("invalid dimensions".to_string())
        .with_context("during tensor reshape");
    Err(error)
}

pub fn with_rich_context(self, message: &str) -> TorshError

Add rich context to an error (includes full backtrace)

Use this for debugging and development environments where detailed error information is valuable. Captures full backtrace and thread information.

Example

use torsh_core::error::{TorshError, Result};

fn critical_operation() -> Result<()> {
    let error = TorshError::InvalidShape("invalid dimensions".to_string())
        .with_rich_context("during critical tensor operation");
    Err(error)
}

pub fn with_metadata(self, message: &str) -> TorshError

Add context with custom metadata (minimal backtrace)

Use this to add structured metadata without the overhead of a full backtrace. Ideal for operation tracking and debugging.

Example

use torsh_core::error::{TorshError, Result};

fn tensor_add(shape1: &[usize], shape2: &[usize]) -> Result<()> {
    let error = TorshError::InvalidShape("incompatible shapes".to_string())
        .with_metadata("during tensor addition")
        .add_metadata("shape1", &format!("{:?}", shape1))
        .add_metadata("shape2", &format!("{:?}", shape2));
    Err(error)
}

pub fn add_metadata(self, key: &str, value: &str) -> TorshError

Add metadata to an existing error

This method allows adding key-value metadata to enrich error context without creating a new error wrapper. If the error is not already a WithContext variant, it will be converted to one.

Example

use torsh_core::error::{TorshError, Result};

fn process_tensor(name: &str, size: usize) -> Result<()> {
    let error = TorshError::AllocationError("out of memory".to_string())
        .add_metadata("tensor_name", name)
        .add_metadata("requested_size", &size.to_string());
    Err(error)
}

pub fn add_shape_metadata(self, key: &str, shape: &[usize]) -> TorshError

Add shape information as metadata

Convenience method for adding tensor shape information to errors.

Example

use torsh_core::error::{TorshError, Result};

fn validate_shape(actual: &[usize], expected: &[usize]) -> Result<()> {
    let error = TorshError::shape_mismatch(expected, actual)
        .add_shape_metadata("actual_shape", actual)
        .add_shape_metadata("expected_shape", expected);
    Err(error)
}

pub fn with_operation(self, operation: &str) -> TorshError

Add operation name as metadata

Convenience method for tracking which operation caused the error.

Example

use torsh_core::error::{TorshError, Result};

fn matmul(a_shape: &[usize], b_shape: &[usize]) -> Result<()> {
    let error = TorshError::shape_mismatch(a_shape, b_shape)
        .with_operation("matmul")
        .add_shape_metadata("lhs_shape", a_shape)
        .add_shape_metadata("rhs_shape", b_shape);
    Err(error)
}

pub fn with_device(self, device_id: usize) -> TorshError

Add device information as metadata

Convenience method for tracking device-related errors.

Example

use torsh_core::error::{TorshError, Result};

fn allocate_on_device(device_id: usize) -> Result<()> {
    let error = TorshError::DeviceError("allocation failed".to_string())
        .with_device(device_id)
        .add_metadata("allocation_type", "tensor");
    Err(error)
}

pub fn with_dtype(self, dtype: &str) -> TorshError

Add dtype information as metadata

Convenience method for tracking data type-related errors.

Example

use torsh_core::error::{TorshError, Result};

fn convert_dtype(from: &str, to: &str) -> Result<()> {
    let error = TorshError::ConversionError("unsupported conversion".to_string())
        .add_metadata("from_dtype", from)
        .add_metadata("to_dtype", to);
    Err(error)
}

pub fn metadata(&self) -> HashMap<String, String>

Get all metadata from the error

Returns an empty map if the error doesn’t have metadata.

pub fn debug_context(&self) -> Option<&ErrorDebugContext>

Get the error’s debug context if available

Returns None if the error is not a WithContext variant.

pub fn format_debug(&self) -> String

Format the error with full debug information

This includes metadata, backtrace, and thread information when available.

Trait Implementations

impl Clone for TorshError

fn clone(&self) -> TorshError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TorshError

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

Formats the value using the given formatter.

impl Display for TorshError

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

Formats the value using the given formatter.

impl Error for TorshError

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 TorshError

fn from(err: Error) -> TorshError

Converts to this type from the input type.

impl From<Error> for TorshError

Available on crate feature serialize only.

fn from(err: Error) -> TorshError

Converts to this type from the input type.

impl From<GeneralError> for TorshError

fn from(source: GeneralError) -> TorshError

Converts to this type from the input type.

impl From<IndexError> for TorshError

fn from(source: IndexError) -> TorshError

Converts to this type from the input type.

impl From<ParseFloatError> for TorshError

fn from(err: ParseFloatError) -> TorshError

Converts to this type from the input type.

impl From<ParseIntError> for TorshError

fn from(err: ParseIntError) -> TorshError

Converts to this type from the input type.

impl<T> From<PoisonError<T>> for TorshError

fn from(err: PoisonError<T>) -> TorshError

Converts to this type from the input type.

impl From<ShapeError> for TorshError

fn from(source: ShapeError) -> TorshError

Converts to this type from the input type.

impl From<TryFromIntError> for TorshError

fn from(err: TryFromIntError) -> TorshError

Converts to this type from the input type.