Struct MSetAttr 

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

Fields

size: Range<A>

occurrence: Range<A>

representation: Option<String>

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

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

Implementations

impl<A> MSetAttr<A>

pub fn new(size: Range<A>, occurrence: Range<A>) -> MSetAttr<A>

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

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

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

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

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

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

impl MSetAttr<IntVal>

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

Trait Implementations

impl<A> Clone for MSetAttr<A>

where A: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A> Debug for MSetAttr<A>

where A: Debug,

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

Formats the value using the given formatter.

impl<A> Default for MSetAttr<A>

fn default() -> MSetAttr<A>

Returns the “default value” for a type.

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

where A: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A> Display for MSetAttr<A>

where A: Display,

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

Formats the value using the given formatter.

impl<A> Eq for MSetAttr<A>

where A: Eq,

impl From<MSetAttr> for MSetAttr<IntVal>

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

Converts to this type from the input type.

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

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

type Output = MSetAttr<C>

The output type of the functorial mapping

fn func_map<F>(self, f: F) -> <MSetAttr<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 MSetAttr<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 MSetAttr<A>

where A: PartialEq,

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

Equality operator ==.

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

Inequality operator !=.

impl<A> Quine for MSetAttr<A>

where A: Quine,

fn ctor_tokens(&self) -> TokenStream

impl<A> Serialize for MSetAttr<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 MSetAttr<A>

where A: PartialEq,

impl TryFrom<MSetAttr<IntVal>> for MSetAttr

type Error = DomainOpError

The type returned in the event of a conversion error.

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

Performs the conversion.

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

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

type Output = MSetAttr<C>

The output type of the functorial mapping

fn try_func_map<E, F>( self, f: F, ) -> Result<<MSetAttr<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.