Trait ComposableElementOp 

pub trait ComposableElementOp<T>: ElementOp<T>
where
    T: ElementOpApply,
{
    type Inverse: ComposableElementOp<T>;
    type ComposeConj: ComposableElementOp<T>;
    type ComposeTranspose: ComposableElementOp<T>;
    type ComposeAdjoint: ComposableElementOp<T>;
}

Trait for element operations that support type-level composition.

Only available when T: ElementOpApply, since composition with Conj/Transpose/Adjoint requires the element type to support those operations.

Required Associated Types

type Inverse: ComposableElementOp<T>

The inverse operation (for this group, each element is its own inverse).

type ComposeConj: ComposableElementOp<T>

Compose with Conj: Self then Conj

type ComposeTranspose: ComposableElementOp<T>

Compose with Transpose: Self then Transpose

type ComposeAdjoint: ComposableElementOp<T>

Compose with Adjoint: Self then Adjoint

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<T> ComposableElementOp<T> for Adjoint

where T: ElementOpApply,

type Inverse = Adjoint

type ComposeConj = Transpose

type ComposeTranspose = Conj

type ComposeAdjoint = Identity

impl<T> ComposableElementOp<T> for Conj

where T: ElementOpApply,

type Inverse = Conj

type ComposeConj = Identity

type ComposeTranspose = Adjoint

type ComposeAdjoint = Transpose

impl<T> ComposableElementOp<T> for Identity

where T: ElementOpApply,

type Inverse = Identity

type ComposeConj = Conj

type ComposeTranspose = Transpose

type ComposeAdjoint = Adjoint

impl<T> ComposableElementOp<T> for Transpose

where T: ElementOpApply,

type Inverse = Transpose

type ComposeConj = Adjoint

type ComposeTranspose = Identity

type ComposeAdjoint = Conj