Crate scsys_traits 

scsys-traits

A collection of useful traits designed to be used throughout the ecosystem.

Modules

convert

dtype

named

ops

string

symbolic

toggle

wrapper

Traits

Appellation

Appellation defines a common interface for establishing a solid name for various entities.

Apply

Apply is a trait that allows for mapping over a reference to a type T by applying a function F to it, producing a new type U. The result is wrapped in a container type defined by the implementor of the trait.

ApplyMut

The ApplyMut trait allows for in-place mapping of a mutable reference to a type T

ApplyOnce

A the ApplyOnce trait is similar to [Map], but it consumes the instance instead of borrowing it;

AsSlice

AsSlice is a generic trait for converting a type into a slice of its elements. This is useful for types that can be represented as a contiguous sequence of elements, such as arrays, vectors, or other collections.

AsSliceMut

AsSliceMut is a generic trait for converting a type into a mutable slice of its elements.

Context

DType

DType is a trait designed to provide additional information regarding the type of a particular value.

Decrement

Decrement defines an interface for decrementing a value.

DecrementMut

DecrementMut is a trait describing the ability to decrement a value in place. It is similar to Decrement, but it allows for mutable access to the value.

DecrementRef

DecrementRef is a trait describing the ability to decrement a value by reference.

Displayable

Displayable simply combines the two major traits core::fmt::Debug and core::fmt::Display into a single trait. This is useful for types that need to be displayed in a human-readable format, such as in debugging or logging.

Increment

Increment defines an interface for incrementing a value.

IncrementMut

IncrementMut is similar to Increment, but it allows for incrementing a value in place.

IncrementRef

IncrementRef is similar to Increment, but it allows for incrementing a value by reference.

IntoInner

IntoInner is typically used for basic structures that wrap a single value.

IsType

The IsType trait provides a method to check if the current type is of a specific type at runtime. This is useful for dynamic type checking in scenarios where the type may not be known at compile time.

Named

Interface for nameable data-structures

RawWrapper

A RawWrapper is the base trait defining all so-called “wrapper” types.

RemoveFnl

This trait defines a method for removing the first and last entries within an entity.

StringFmt

StringFmt is a trait that provides methods for formatting strings. Note This crate requires the alloc feature

Symbolic

Symbolic denotes a type consisting of some single or set of value(s) that can are considered displayable. Essentially, this trait is a wrapper around the Displayable trait enabling additional implementations

TypeOf

The TypeOf trait automatically provides a way to check if a type is of a specific type at compile time. This is useful for generic programming and type checking.

TypeTag

Typically, TypeTag is used for uninitaliziable enums with no variants

Wrapper

The Wrapper trait is used to establish a common interface for all simplemented structures that “wrap” a single value. Essentially, any type capable of implementing #[repr(transparent)] can be considered a wrapper.