Trait UnderlierView

Source

pub unsafe trait UnderlierView:
    TransparentWrapper<Self::Underlier>
    + Sized
    + Zeroable
    + Copy
    + Send
    + Sync
    + 'static {
    type Underlier: Underlier;

    // Provided methods
    fn to_underlier(self) -> Self::Underlier { ... }
    fn to_underlier_ref(&self) -> &Self::Underlier { ... }
    fn to_underlier_ref_mut(&mut self) -> &mut Self::Underlier { ... }
    fn to_underliers_ref(val: &[Self]) -> &[Self::Underlier] { ... }
    fn to_underliers_ref_mut(val: &mut [Self]) -> &mut [Self::Underlier] { ... }
    fn from_underlier(val: Self::Underlier) -> Self { ... }
    fn from_underlier_ref(val: &Self::Underlier) -> &Self { ... }
    fn from_underlier_ref_mut(val: &mut Self::Underlier) -> &mut Self { ... }
    fn from_underliers_ref(val: &[Self::Underlier]) -> &[Self] { ... }
    fn from_underliers_ref_mut(val: &mut [Self::Underlier]) -> &mut [Self] { ... }
    fn mutate_underlier(
        self,
        f: impl FnOnce(Self::Underlier) -> Self::Underlier,
    ) -> Self { ... }
}

Expand description

A type stored exactly as some underlier, and freely viewable as one.

A binary field element is a bit pattern with arithmetic attached. The bits sit in an underlier, and the element type wraps it to give those bits meaning.

Declaring that wrapper transparent means the two share an address, a size, and a bit pattern:

    element    [ bits ]  <- arithmetic attached
    underlier  [ bits ]  <- same address, same size, nothing to convert

So a value, a reference, or a whole slice can be viewed as the other side for free. Viewing a slice matters most, since it lets bulk code work on plain bits without copying.

The wrapping alone would be expressible with conversions in both directions. What those cannot give is the underlier’s name. Generic code needs that name to state bounds against it. Carrying it as an associated type is what this trait adds.