Crate scsys

Expand description

§scsys

Welcome to scsys, this crate is tasked with providing a generic set of tools for the scsys.io ecosystem. It is designed to be a foundational library that helps establish a sense of consistency between individual efforts while working to reduce its overall footprint through modularization and feature-gating. These characteristics make it suitable for use both within the ecosystem and outside of it.

Modules§

config: the config module implements a set of standardized configuration schemas A collection of common configuration primitives and utilities used throughout the scsys-io ecosystem.
crypto: cryptographic primitives and utilities implemented for the ecosystem cryptographic primitives and utilities for the scsys ecosystem.
error: this module implements various error-handling primitives and utilities ths module implements various error-handling primitives and utilities
id: this module defines the generic Id wrapper and its implementations
prelude
rand: Utilities for random number generation
rand_distr: Generating random samples from probability distributions.
state: this module provides a set of states for state-related workloads (State & NState) this module implements a generic State wrapper and provides several traits to support state management and other stateful workloads.
time: a temporal module establishing a core set of time-related primitives and utilities such as Timestamp
traits: this module contains various traits commonly used throughout the scsys ecosystem
types
utils: utilities for working with the scsys ecosystem

Macros§

fmt_wrapper: Example
get_field
getter: A procedural macro for generativly creating getter methods; i.e. $field_name() -> &$field_type and $field_name_mut() -> &mut $field_type
gsw: The gsw macro generates getter and setter methods for the fields of a struct. At the moment, the macro can handle any type; for types that implement the Copy trait, simply drop the & to the left of each type.
wrapper

Structs§

ErrorBase
Id: Id is a generic identifier type that wraps a value of type T.
LinearDirectionIter: An iterator over the variants of LinearDirection
StageIter: An iterator over the variants of Stage
State: State is generic over some type Q that implements the RawState trait.
StateBase: StateBase is an abstract object that allows a particular kind of state to be associated with some generic state Q
StdError: The StdError type is a generic error type that is generic over the error kind; this enables us to distinguish between distinctly different error types.
Timestamp: Timestamp is a generic implementation of a type that represents some point in time.

Enums§

CoreError
EventStage: An EventStage is a generic enumeration that represents the three stages of an event in a system, allowing for the association of a type T with each stage. The stages are:
LinearDirection: The LinearDirection implementation enumerates the three pssoible movements in one-dimensional space, namely:
Stage: Auto-generated discriminant enum variants

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.
Container: The Container trait is a higher-level abstraction over RawContainer.
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.
ErrorKind: this trait is used to denote various error kinds for use throughout the sdk
Functor: The Functor trait extends the HKT trait to provide a way to map over its content(s) using a function f that transforms values of type T into values of type U.
Get: Get defines an interface for entities that can be accessed by a key; the design is similar to the Index trait in the standard library, however, uses the Borrow trait to allow for more flexible key types.
GetMut: GetMut defines an interface for entities that can be accessed by a key; the design is similar to the IndexMut trait in the standard library
HKT: The HKT trait defines an interface for higher-kinded types (HKT).
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
KeyedContainer
Named: Interface for nameable data-structures
Now: The Now trait provides a common creation routines for all datetime implementations.
RawContainer: RawContainer defines a standard interface for all containers that are used to store other entities.
RawTimestamp: a private trait used to mark types capable of being uses as a basetype for a Timestamp.
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.
StateRepr: The StateRepr trait defines the base type for stateful items, allowing for a generic item type to be associated with the state.
Stateful: Stateful is a trait establishing a common interface for all types that are state-aware.
Store
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
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.

Type Aliases§

BoxErr: A type alias for a Err whose generic type is a Box of a trait object implementing core::error::Error.
BoxError: Type alias for a boxed error with send, sync, and static flags enabled
BoxResult: Type alias for the standard result used
NState: A type alias for a StateBase equipped with a Nary kind of state
Result: a type alias for a Result type pre-configured with the [Error] type

Derive Macros§

Display
Getter
Set
VariantConstructors: This macro automatically generates functional constructors for all enclosed variants.
With
Wrapper: The Wrapper macro is designed for single-field structs, implementing additional methods supporting interactions with the inner value

Crate scsysCopy item path