Struct SetAttr 

pub struct SetAttr<A = i32> {
    pub size: Range<A>,
    pub representation: Option<String>,
}

Fields

size: Range<A>

representation: Option<String>

Optional user-facing representation preference (short name), e.g. "packed".

Written in Essence as set (representation packed) of …. When present, representation selection heuristics default to this representation if it is applicable.

Implementations

impl<A> SetAttr<A>

pub fn new(size: Range<A>) -> SetAttr<A>

pub fn new_min_max_size(min: A, max: A) -> SetAttr<A>

pub fn new_min_size(min: A) -> SetAttr<A>

pub fn new_max_size(max: A) -> SetAttr<A>

pub fn new_size(sz: A) -> SetAttr<A>

pub fn with_representation(self, name: impl Into<String>) -> SetAttr<A>

Set the representation preference (Essence short name), returning the updated attributes.

impl SetAttr<IntVal>

pub fn resolve(&self) -> Result<SetAttr, DomainOpError>

Trait Implementations

impl<A> Clone for SetAttr<A>

where A: Clone,

fn clone(&self) -> SetAttr<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A> Debug for SetAttr<A>

where A: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<A> Default for SetAttr<A>

fn default() -> SetAttr<A>

Returns the “default value” for a type.

impl<'de, A> Deserialize<'de> for SetAttr<A>

where A: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<SetAttr<A>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A> Display for SetAttr<A>

where A: Display,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<A> Eq for SetAttr<A>

where A: Eq,

impl From<SetAttr> for SetAttr<IntVal>

fn from(val: SetAttr) -> SetAttr<IntVal>

Converts to this type from the input type.

impl<B, C> FuncMap<B, C> for SetAttr<B>

where Range<B>: FuncMap<B, C, Output = Range<C>>, Option<String>: Sized,

type Output = SetAttr<C>

The output type of the functorial mapping

fn func_map<F>(self, f: F) -> <SetAttr<B> as FuncMap<B, C>>::Output

where F: FnMut(B) -> C,

Applies the closure f to self in a functorial way

fn func_map_over<Q, F>(self, f: F) -> Self::Output

where F: FnMut(A) -> B, Q: FuncMarker<P>,

Applies the closure f to self in a functorial way, allowing explicit specification of the marker type P

impl<A> Hash for SetAttr<A>

where A: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<A> PartialEq for SetAttr<A>

where A: PartialEq,

fn eq(&self, other: &SetAttr<A>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<A> Quine for SetAttr<A>

where A: Quine,

fn ctor_tokens(&self) -> TokenStream

impl<A> Serialize for SetAttr<A>

where A: Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A> StructuralPartialEq for SetAttr<A>

where A: PartialEq,

impl TryFrom<SetAttr<IntVal>> for SetAttr

type Error = DomainOpError

The type returned in the event of a conversion error.

fn try_from( val: SetAttr<IntVal>, ) -> Result<SetAttr, <SetAttr as TryFrom<SetAttr<IntVal>>>::Error>

Performs the conversion.

impl<B, C> TryFuncMap<B, C> for SetAttr<B>

where Range<B>: TryFuncMap<B, C, Output = Range<C>>, Option<String>: Sized,

type Output = SetAttr<C>

The output type of the functorial mapping

fn try_func_map<E, F>( self, f: F, ) -> Result<<SetAttr<B> as TryFuncMap<B, C>>::Output, E>

where F: FnMut(B) -> Result<C, E>,

Tries to apply the closure f to self in a functorial way

fn try_func_map_over<Q, E, F>(self, f: F) -> Result<Self::Output, E>

where F: FnMut(A) -> Result<B, E>, Q: FuncMarker<P>,

Tries to apply the closure f to self in a functorial way, allowing explicit specification of the marker type P

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.