Crate rspace 

rspace is a fundmanetal crate looking to support containers via a set of well established interfaces, traits, primitives, and other useful tools. The crate is working towards becoming no_std compatible, seeking to support embedded and other resource constrained environments. Additionally, the crate is extensively feature-gated to ensure it remains as lightweight and modular as possible.

Modules

error

this module defines the core error type for the crate

point

traits

Various traits used to establish a solid foundation for defining and manipulating containers, spaces, fields, and other related abstractions. The core trait, RawSpace, is a fundamental building block for defining spaces (i.e. containers containing elements of a specific type). The Container trait builds upon RawSpace to provide a more robust interface for containers and higher-kinded abstractions.

Structs

Point

The Point implementation is designed a generic, 2-dimensional point object used to define coordinates, vectors, or positions in a 2D space.

Enums

Error

The custom error type for the crate.

Traits

Apply

Apply establishes a binary operator for applying a given object, typically a function or closure, onto a target object, producing some output.

ApplyMut

The ApplyMut trait defines an interface for objects capable of mutably borrowing themselves to apply the given function onto themselves or their elements to produce some output.

ApplyOnce

The ApplyOnce trait defines an interface for objects capable of consuming themselves to apply the given function onto themselves or their elements to produce some output.

Container

The Container trait is a higher-kinded trait used to establish an interface for defining containers themselves.

ContainerIndex

ContainerIter

The ContainerIter trait extends the Container trait to provide an interface for obtaining iterators over the elements of the container.

ContainerIterMut

FunctorDeprecated

The Functor trait describes an interface for a higher-kinded type that can be mapped over. The trait is parameterized over a function F and a target type T, allowing for granular control over the mapping process itself, relying on associated types like Cont<U> to define the resulting container type after the mapping operation and the Elem type to specify the type of elements contained within the functor before the mapping operation is applied. Moreover, the apply method takes ownership of the functor allowing for distinct implementations for referenced, mutabled, and owned instances.

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

MapInto

MapInto defines an interface for containers capable of applying a given function onto each of their elements and consuming the container in the process, producing a new container containing the captured results of each invocation. The trait’s design allows implementors to specify the exact function signature and output type, utilizing associated type parameters to define the container and its current element type.

MapTo

The MapTo trait is similar to MapInto, but it operates on references to the container rather than consuming it. This allows for mapping functions over the elements of a container while retaining ownership of the original container.

RawSpace

The RawSpace trait is used to define a base interface for all containers whose elements are of one specific type.

RawSpaceMut

RawSpaceMut is a trait that provides various mutable methods for accessing elements.

RawSpaceRef

RawSpaceRef is a trait that provides various read-only methods for accessing elements.

RawStore

The RawStore trait is a marker trait for key-value store containers.

ScalarSpace

ScalarSpace defins a type of space that consists of a single element. This trait is useful in that it generally allows for a tensor-like treatment of scalar values within more complex mathematical structures.

SliceSpace

SliceSpace is used to define sequential collections, spaces, or containers that can be viewed as slices.

SliceSpaceMut

SliceSpaceMut is used to define sequential collections, spaces, or containers that can be

Store

The Store trait is used to define a key-value store container.

StoreEntry

StoreEntry establishes a common interface for entries within a key-value store.

TryApply

TryApplyMut

TryApplyOnce

Type Aliases

PointView

An instance of the Point implementation containing owned references to the inner values.

PointViewMut

An instance of the Point implementation containing mutable references to the inner values.

RawPoint

A Point whose elements are raw pointers to X and Y

RawPointMut

A mutable Point whose elements are raw pointers to X and Y

Result

a type alias for a Result configured to use the custom Error type.