Struct CanHomRef

pub struct CanHomRef<'a, R, S>
where
    R: RingStore,
    S: RingStore,
    S::Type: CanHomFrom<R::Type>,
{ /* private fields */ }

A wrapper of CanHomFrom::Homomorphism that does not own the data associated with the homomorphism. Use cases are rare, prefer to use CanHom whenever possible.

More concretely, this should only be used when you only have a reference to <R as CanHomFrom<S>>::Homomorphism, but cannot refactor code to wrap that object in a CanHom instead. The main situation where this occurs is when implementing CanHomFrom, since a the lifetime of CanHom is bound by the lifetime of the domain and codomain rings, but CanHomFrom::Type does not allow this.

Availability

This API is marked as unstable and is only available when the unstable-enable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

Implementations

impl<'a, R, S> CanHomRef<'a, R, S>

where R: RingStore, S: RingStore, S::Type: CanHomFrom<R::Type>,

pub fn raw_hom(&self) -> &<S::Type as CanHomFrom<R::Type>>::Homomorphism

Availability

This API is marked as unstable and is only available when the unstable-enable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn from_raw_parts( from: R, to: S, data: &'a <S::Type as CanHomFrom<R::Type>>::Homomorphism, ) -> Self

Availability

This API is marked as unstable and is only available when the unstable-enable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

Trait Implementations

impl<'a, R, S> Clone for CanHomRef<'a, R, S>

where R: RingStore + Clone, S: RingStore + Clone, S::Type: CanHomFrom<R::Type>,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, R, S> Homomorphism<<R as RingStore>::Type, <S as RingStore>::Type> for CanHomRef<'a, R, S>

where R: RingStore, S: RingStore, S::Type: CanHomFrom<R::Type>,

type CodomainStore = S

type DomainStore = R

fn map(&self, el: El<R>) -> El<S>

fn map_ref(&self, el: &El<R>) -> El<S>

fn domain(&self) -> &R

fn codomain(&self) -> &S

fn mul_assign_map(&self, lhs: &mut Codomain::Element, rhs: Domain::Element)

fn mul_assign_ref_map(&self, lhs: &mut Codomain::Element, rhs: &Domain::Element)

fn mul_map( &self, lhs: Codomain::Element, rhs: Domain::Element, ) -> Codomain::Element

fn mul_ref_fst_map( &self, lhs: &Codomain::Element, rhs: Domain::Element, ) -> Codomain::Element

fn mul_ref_snd_map( &self, lhs: Codomain::Element, rhs: &Domain::Element, ) -> Codomain::Element

fn mul_ref_map( &self, lhs: &Codomain::Element, rhs: &Domain::Element, ) -> Codomain::Element

fn compose<F, PrevDomain: ?Sized + RingBase>( self, prev: F, ) -> ComposedHom<PrevDomain, Domain, Codomain, F, Self>

where Self: Sized, F: Homomorphism<PrevDomain, Domain>,

impl<'a, R, S> Copy for CanHomRef<'a, R, S>

where R: RingStore + Copy, S: RingStore + Copy, S::Type: CanHomFrom<R::Type>, El<R>: Copy, El<S>: Copy,