Trait HasStructure 

pub trait HasStructure {
    type Store<S>: HasStructure<Structure = S>
       where S: TensorStructure;
    type Structure: TensorStructure;
    type Scalar;
    type ScalarRef<'a>
       where Self: 'a;

    // Required methods
    fn map_structure<O: TensorStructure>(
        self,
        f: impl Fn(Self::Structure) -> O,
    ) -> Self::Store<O>;
    fn map_structure_result<O: TensorStructure, Er>(
        self,
        f: impl Fn(Self::Structure) -> Result<O, Er>,
    ) -> Result<Self::Store<O>, Er>;
    fn structure(&self) -> &Self::Structure;
    fn mut_structure(&mut self) -> &mut Self::Structure;
    fn scalar(self) -> Option<Self::Scalar>;
    fn scalar_ref(&self) -> Option<Self::ScalarRef<'_>>;
    fn map_same_structure(
        self,
        f: impl FnOnce(Self::Structure) -> Self::Structure,
    ) -> Self;

    // Provided methods
    fn set_structure_name<N>(&mut self, name: N)
       where Self::Structure: HasName<Name = N> { ... }
    fn structure_name(&self) -> Option<<Self::Structure as HasName>::Name>
       where Self::Structure: HasName { ... }
    fn structure_id(&self) -> Option<<Self::Structure as HasName>::Args>
       where Self::Structure: HasName { ... }
}

Required Associated Types

type Store<S>: HasStructure<Structure = S> where S: TensorStructure

type Structure: TensorStructure

type Scalar

type ScalarRef<'a> where Self: 'a

Required Methods

fn map_structure<O: TensorStructure>( self, f: impl Fn(Self::Structure) -> O, ) -> Self::Store<O>

fn map_structure_result<O: TensorStructure, Er>( self, f: impl Fn(Self::Structure) -> Result<O, Er>, ) -> Result<Self::Store<O>, Er>

fn structure(&self) -> &Self::Structure

fn mut_structure(&mut self) -> &mut Self::Structure

fn scalar(self) -> Option<Self::Scalar>

fn scalar_ref(&self) -> Option<Self::ScalarRef<'_>>

fn map_same_structure( self, f: impl FnOnce(Self::Structure) -> Self::Structure, ) -> Self

Provided Methods

fn set_structure_name<N>(&mut self, name: N)

where Self::Structure: HasName<Name = N>,

fn structure_name(&self) -> Option<<Self::Structure as HasName>::Name>

where Self::Structure: HasName,

fn structure_id(&self) -> Option<<Self::Structure as HasName>::Args>

where Self::Structure: HasName,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<Aind: AbsInd> HasStructure for SymbolicTensor<Aind>

type Structure = OrderedStructure<LibraryRep, Aind>

type Scalar = Atom

type ScalarRef<'a> = &'a Atom where Self: 'a

type Store<S> = TensorShell<S> where S: TensorStructure

impl<C, S> HasStructure for ParamOrConcrete<C, S>

where C: HasStructure<Structure = S>, S: TensorStructure,

type Scalar = ConcreteOrParam<<C as HasStructure>::Scalar>

type ScalarRef<'a> = ConcreteOrParamRef<'a, <C as HasStructure>::ScalarRef<'a>> where Self: 'a

type Structure = S

type Store<U> = ParamOrConcrete<<C as HasStructure>::Store<U>, U> where U: TensorStructure

impl<S> HasStructure for ParamTensor<S>

where S: TensorStructure,

type Structure = S

type Scalar = Atom

type ScalarRef<'a> = AtomView<'a> where Self: 'a

type Store<U> = ParamTensor<U> where U: TensorStructure

impl<S: TensorStructure> HasStructure for TensorShell<S>

type Structure = S

type Scalar = ()

type ScalarRef<'a> = &'a () where Self: 'a

type Store<U> = TensorShell<U> where U: TensorStructure

impl<T, I> HasStructure for DataTensor<T, I>

where I: TensorStructure,

type Scalar = T

type ScalarRef<'a> = &'a T where Self: 'a

type Structure = I

type Store<S> = DataTensor<T, S> where S: TensorStructure

impl<T, I> HasStructure for DenseTensor<T, I>

where I: TensorStructure,

type Scalar = T

type ScalarRef<'a> = &'a T where Self: 'a

type Structure = I

type Store<S> = DenseTensor<T, S> where S: TensorStructure

impl<T, I> HasStructure for SparseTensor<T, I>

where I: TensorStructure,

type Scalar = T

type ScalarRef<'a> = &'a T where Self: 'a

type Structure = I

type Store<S> = SparseTensor<T, S> where S: TensorStructure

impl<T, S: TensorStructure> HasStructure for EvalTensor<T, S>

type Scalar = T

type ScalarRef<'a> = &'a T where Self: 'a

type Structure = S

type Store<U> = EvalTensor<T, U> where U: TensorStructure

impl<T: Clone, S: TensorStructure> HasStructure for RealOrComplexTensor<T, S>

type Scalar = RealOrComplex<T>

type ScalarRef<'a> = RealOrComplexRef<'a, T> where Self: 'a

type Structure = S

type Store<U> = RealOrComplexTensor<T, U> where U: TensorStructure

impl<T: HasStructure + TensorStructure> HasStructure for DummyLibraryTensor<T>

type Store<S> = <T as HasStructure>::Store<S> where S: TensorStructure

type Scalar = <T as HasStructure>::Scalar

type ScalarRef<'a> = <T as HasStructure>::ScalarRef<'a> where Self: 'a

type Structure = <T as HasStructure>::Structure