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>) -> Self

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

pub fn new_min_size(min: A) -> Self

pub fn new_max_size(max: A) -> Self

pub fn new_size(sz: A) -> Self

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

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

impl MSetAttr<IntVal>

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

Trait Implementations

impl<A: Clone> Clone for MSetAttr<A>

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> Debug for MSetAttr<A>

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

Formats the value using the given formatter.

impl<A> Default for MSetAttr<A>

fn default() -> Self

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<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: Display> Display for MSetAttr<A>

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

Formats the value using the given formatter.

impl<A: Eq> Eq for MSetAttr<A>

impl From<MSetAttr> for MSetAttr<IntVal>

fn from(val: MSetAttr<i32>) -> Self

Converts to this type from the input type.

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

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

type Output = MSetAttr<C>

The output type of the functorial mapping

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

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

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> PartialEq for MSetAttr<A>

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::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A: PartialEq> StructuralPartialEq for MSetAttr<A>

impl TryFrom<MSetAttr<IntVal>> for MSetAttr<i32>

type Error = DomainOpError

The type returned in the event of a conversion error.

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

Performs the conversion.

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

where Range<B>: TryFuncMap<B, C, TypeParam<0usize>, 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<Self::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.