Enum Domain 

pub enum Domain {
    Ground(Moo<GroundDomain>),
    Unresolved(Moo<UnresolvedDomain>),
}

Variants

Ground(Moo<GroundDomain>)

A fully resolved domain

Unresolved(Moo<UnresolvedDomain>)

A domain which may contain references

Implementations

impl Domain

pub fn bool() -> DomainPtr

Create a new boolean domain and return a pointer to it. Boolean domains are always ground (see GroundDomain::Bool).

pub fn empty(ty: ReturnType) -> DomainPtr

Create a new empty domain of the given type and return a pointer to it. Empty domains are always ground (see GroundDomain::Empty).

pub fn int<T>(ranges: Vec<T>) -> DomainPtr

where T: Into<Range<IntVal>> + TryInto<Range<i32>> + Clone,

Create a new int domain with the given ranges. If the ranges are all ground, the variant will be GroundDomain::Int. Otherwise, it will be UnresolvedDomain::Int.

pub fn int_ground(ranges: Vec<Range<i32>>) -> DomainPtr

Create a new ground integer domain with the given ranges

pub fn set<T>(attr: T, inner_dom: DomainPtr) -> DomainPtr

where T: Into<SetAttr<IntVal>> + TryInto<SetAttr<i32>> + Clone,

Create a new set domain with the given element domain and attributes. If the element domain and the attributes are ground, the variant will be GroundDomain::Set. Otherwise, it will be UnresolvedDomain::Set.

pub fn matrix(inner_dom: DomainPtr, idx_doms: Vec<DomainPtr>) -> DomainPtr

Create a new matrix domain with the given element domain and index domains. If the given domains are all ground, the variant will be GroundDomain::Matrix. Otherwise, it will be UnresolvedDomain::Matrix.

pub fn tuple(inner_doms: Vec<DomainPtr>) -> DomainPtr

Create a new tuple domain with the given element domains. If the given domains are all ground, the variant will be GroundDomain::Tuple. Otherwise, it will be UnresolvedDomain::Tuple.

pub fn record(entries: Vec<RecordEntry>) -> DomainPtr

Create a new tuple domain with the given entries. If the entries are all ground, the variant will be GroundDomain::Record. Otherwise, it will be UnresolvedDomain::Record.

pub fn reference(ptr: DeclarationPtr) -> Option<DomainPtr>

Create a new UnresolvedDomain::Reference domain from a domain letting

pub fn function<T>(attrs: T, dom: DomainPtr, cdom: DomainPtr) -> DomainPtr

where T: Into<FuncAttr<IntVal>> + TryInto<FuncAttr<i32>> + Clone,

Create a new function domain

pub fn resolve(&self) -> Option<Moo<GroundDomain>>

If this domain is ground, return a Moo to the underlying GroundDomain. Otherwise, try to resolve it; Return None if this is not yet possible. Domains which contain references to givens cannot be resolved until these givens are substituted for their concrete values.

pub fn as_ground(&self) -> Option<&GroundDomain>

If this domain is already ground, return a reference to the underlying GroundDomain. Otherwise, return None. This method does NOT perform any resolution. See also: Domain::resolve.

pub fn as_ground_mut(&mut self) -> Option<&mut GroundDomain>

If this domain is already ground, return a mutable reference to the underlying GroundDomain. Otherwise, return None. This method does NOT perform any resolution.

pub fn as_unresolved(&self) -> Option<&UnresolvedDomain>

If this domain is unresolved, return a reference to the underlying UnresolvedDomain.

pub fn as_unresolved_mut(&mut self) -> Option<&mut UnresolvedDomain>

If this domain is unresolved, return a mutable reference to the underlying UnresolvedDomain.

pub fn as_dom_empty(&self) -> Option<&ReturnType>

If this is [GroundDomain::Empty(ty)], get a reference to the return type ty

pub fn as_dom_empty_mut(&mut self) -> Option<&mut ReturnType>

If this is [GroundDomain::Empty(ty)], get a mutable reference to the return type ty

pub fn is_bool(&self) -> bool

True if this is GroundDomain::Bool

pub fn is_int(&self) -> bool

True if this is a GroundDomain::Int or an UnresolvedDomain::Int

pub fn as_int(&self) -> Option<Vec<Range<IntVal>>>

If this domain is GroundDomain::Int or [UnresolveDomain::Int], get its ranges. The ranges are cloned and upcast to Range if necessary.

pub fn as_int_mut(&mut self) -> Option<&mut Vec<Range<IntVal>>>

If this is an int domain, get a mutable reference to its ranges. The domain always becomes UnresolvedDomain::Int after this operation.

pub fn as_int_ground(&self) -> Option<&Vec<Range<i32>>>

If this is a [GroundDomain::Int(rngs)], get an immutable reference to rngs.

pub fn as_int_ground_mut(&mut self) -> Option<&mut Vec<Range<i32>>>

If this is a [GroundDomain::Int(rngs)], get an immutable reference to rngs.

pub fn as_matrix(&self) -> Option<(DomainPtr, Vec<DomainPtr>)>

If this is a matrix domain, get pointers to its element domain and index domains.

pub fn as_matrix_mut(&mut self) -> Option<(&mut DomainPtr, &mut Vec<DomainPtr>)>

If this is a matrix domain, get mutable references to its element domain and its vector of index domains. The domain always becomes UnresolvedDomain::Matrix after this operation.

pub fn as_matrix_ground( &self, ) -> Option<(&Moo<GroundDomain>, &Vec<Moo<GroundDomain>>)>

If this is a GroundDomain::Matrix, get immutable references to its element and index domains

pub fn as_matrix_ground_mut( &mut self, ) -> Option<(&mut Moo<GroundDomain>, &mut Vec<Moo<GroundDomain>>)>

If this is a GroundDomain::Matrix, get mutable references to its element and index domains

pub fn as_set(&self) -> Option<(SetAttr<IntVal>, DomainPtr)>

If this is a set domain, get its attributes and a pointer to its element domain.

pub fn as_set_mut(&mut self) -> Option<(&mut SetAttr<IntVal>, &mut DomainPtr)>

If this is a set domain, get mutable reference to its attributes and element domain. The domain always becomes UnresolvedDomain::Set after this operation.

pub fn as_set_ground(&self) -> Option<(&SetAttr<i32>, &Moo<GroundDomain>)>

If this is a GroundDomain::Set, get immutable references to its attributes and inner domain

pub fn as_set_ground_mut( &mut self, ) -> Option<(&mut SetAttr<i32>, &mut Moo<GroundDomain>)>

If this is a GroundDomain::Set, get mutable references to its attributes and inner domain

pub fn as_tuple(&self) -> Option<Vec<DomainPtr>>

If this is a tuple domain, get pointers to its element domains.

pub fn as_tuple_mut(&mut self) -> Option<&mut Vec<DomainPtr>>

If this is a tuple domain, get a mutable reference to its vector of element domains. The domain always becomes UnresolvedDomain::Tuple after this operation.

pub fn as_tuple_ground(&self) -> Option<&Vec<Moo<GroundDomain>>>

If this is a GroundDomain::Tuple, get immutable references to its element domains

pub fn as_tuple_ground_mut(&mut self) -> Option<&mut Vec<Moo<GroundDomain>>>

If this is a GroundDomain::Tuple, get mutable reference to its element domains

pub fn as_record(&self) -> Option<Vec<RecordEntry>>

If this is a record domain, clone and return its entries.

pub fn as_record_ground(&self) -> Option<&Vec<RecordEntryGround>>

If this is a GroundDomain::Record, get a mutable reference to its entries

pub fn as_record_mut(&mut self) -> Option<&mut Vec<RecordEntry>>

If this is a record domain, get a mutable reference to its list of entries. The domain always becomes UnresolvedDomain::Record after this operation.

pub fn as_record_ground_mut(&mut self) -> Option<&mut Vec<RecordEntryGround>>

If this is a GroundDomain::Record, get a mutable reference to its entries

pub fn union(&self, other: &Domain) -> Result<Domain, DomainOpError>

Compute the intersection of two domains

pub fn intersect(&self, other: &Domain) -> Result<Domain, DomainOpError>

Compute the intersection of two ground domains

pub fn values(&self) -> Result<impl Iterator<Item = Literal>, DomainOpError>

If the domain is ground, return an iterator over its values

pub fn length(&self) -> Result<u64, DomainOpError>

If the domain is ground, return its size bound

pub fn from_literal_vec(vals: &[Literal]) -> Result<DomainPtr, DomainOpError>

Construct a ground domain from a slice of values

pub fn contains(&self, lit: &Literal) -> Result<bool, DomainOpError>

Returns true if lit is a valid value of this domain

Trait Implementations

impl Biplate<Domain> for Domain

fn biplate(&self) -> (Tree<Domain>, Box<dyn Fn(Tree<Domain>) -> Domain>)

Definition of a Biplate.

fn with_children_bi(&self, children: VecDeque<To>) -> Self

Reconstructs the node with the given children.

fn descend_bi(&self, op: &impl Fn(To) -> To) -> Self

Biplate variant of [Uniplate::descend]

fn universe_bi(&self) -> VecDeque<To>

Gets all children of a node, including itself and all children.

fn children_bi(&self) -> VecDeque<To>

Returns the children of a type. If to == from then it returns the original element (in contrast to children).

fn transform_bi(&self, op: &impl Fn(To) -> To) -> Self

Applies the given function to all nodes bottom up.

fn holes_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over all direct children of the input, paired with a function that “fills the hole” where the child was with a new value.

fn contexts_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over the universe of the input, paired with a function that “fills the hole” where the child was with a new value.

impl Biplate<Expression> for Domain

fn biplate(&self) -> (Tree<Expression>, Box<dyn Fn(Tree<Expression>) -> Domain>)

Definition of a Biplate.

fn with_children_bi(&self, children: VecDeque<To>) -> Self

Reconstructs the node with the given children.

fn descend_bi(&self, op: &impl Fn(To) -> To) -> Self

Biplate variant of [Uniplate::descend]

fn universe_bi(&self) -> VecDeque<To>

Gets all children of a node, including itself and all children.

fn children_bi(&self) -> VecDeque<To>

Returns the children of a type. If to == from then it returns the original element (in contrast to children).

fn transform_bi(&self, op: &impl Fn(To) -> To) -> Self

Applies the given function to all nodes bottom up.

fn holes_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over all direct children of the input, paired with a function that “fills the hole” where the child was with a new value.

fn contexts_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over the universe of the input, paired with a function that “fills the hole” where the child was with a new value.

impl Biplate<GroundDomain> for Domain

fn biplate( &self, ) -> (Tree<GroundDomain>, Box<dyn Fn(Tree<GroundDomain>) -> Domain>)

Definition of a Biplate.

fn with_children_bi(&self, children: VecDeque<To>) -> Self

Reconstructs the node with the given children.

fn descend_bi(&self, op: &impl Fn(To) -> To) -> Self

Biplate variant of [Uniplate::descend]

fn universe_bi(&self) -> VecDeque<To>

Gets all children of a node, including itself and all children.

fn children_bi(&self) -> VecDeque<To>

Returns the children of a type. If to == from then it returns the original element (in contrast to children).

fn transform_bi(&self, op: &impl Fn(To) -> To) -> Self

Applies the given function to all nodes bottom up.

fn holes_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over all direct children of the input, paired with a function that “fills the hole” where the child was with a new value.

fn contexts_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over the universe of the input, paired with a function that “fills the hole” where the child was with a new value.

impl Biplate<IntVal> for Domain

fn biplate(&self) -> (Tree<IntVal>, Box<dyn Fn(Tree<IntVal>) -> Domain>)

Definition of a Biplate.

fn with_children_bi(&self, children: VecDeque<To>) -> Self

Reconstructs the node with the given children.

fn descend_bi(&self, op: &impl Fn(To) -> To) -> Self

Biplate variant of [Uniplate::descend]

fn universe_bi(&self) -> VecDeque<To>

Gets all children of a node, including itself and all children.

fn children_bi(&self) -> VecDeque<To>

Returns the children of a type. If to == from then it returns the original element (in contrast to children).

fn transform_bi(&self, op: &impl Fn(To) -> To) -> Self

Applies the given function to all nodes bottom up.

fn holes_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over all direct children of the input, paired with a function that “fills the hole” where the child was with a new value.

fn contexts_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over the universe of the input, paired with a function that “fills the hole” where the child was with a new value.

impl Biplate<Moo<Domain>> for Domain

fn biplate(&self) -> (Tree<DomainPtr>, Box<dyn Fn(Tree<DomainPtr>) -> Domain>)

Definition of a Biplate.

fn with_children_bi(&self, children: VecDeque<To>) -> Self

Reconstructs the node with the given children.

fn descend_bi(&self, op: &impl Fn(To) -> To) -> Self

Biplate variant of [Uniplate::descend]

fn universe_bi(&self) -> VecDeque<To>

Gets all children of a node, including itself and all children.

fn children_bi(&self) -> VecDeque<To>

Returns the children of a type. If to == from then it returns the original element (in contrast to children).

fn transform_bi(&self, op: &impl Fn(To) -> To) -> Self

Applies the given function to all nodes bottom up.

fn holes_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over all direct children of the input, paired with a function that “fills the hole” where the child was with a new value.

fn contexts_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over the universe of the input, paired with a function that “fills the hole” where the child was with a new value.

impl Biplate<RecordEntry> for Domain

fn biplate( &self, ) -> (Tree<RecordEntry>, Box<dyn Fn(Tree<RecordEntry>) -> Domain>)

Definition of a Biplate.

fn with_children_bi(&self, children: VecDeque<To>) -> Self

Reconstructs the node with the given children.

fn descend_bi(&self, op: &impl Fn(To) -> To) -> Self

Biplate variant of [Uniplate::descend]

fn universe_bi(&self) -> VecDeque<To>

Gets all children of a node, including itself and all children.

fn children_bi(&self) -> VecDeque<To>

Returns the children of a type. If to == from then it returns the original element (in contrast to children).

fn transform_bi(&self, op: &impl Fn(To) -> To) -> Self

Applies the given function to all nodes bottom up.

fn holes_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over all direct children of the input, paired with a function that “fills the hole” where the child was with a new value.

fn contexts_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over the universe of the input, paired with a function that “fills the hole” where the child was with a new value.

impl Biplate<Reference> for Domain

fn biplate(&self) -> (Tree<Reference>, Box<dyn Fn(Tree<Reference>) -> Domain>)

Definition of a Biplate.

fn with_children_bi(&self, children: VecDeque<To>) -> Self

Reconstructs the node with the given children.

fn descend_bi(&self, op: &impl Fn(To) -> To) -> Self

Biplate variant of [Uniplate::descend]

fn universe_bi(&self) -> VecDeque<To>

Gets all children of a node, including itself and all children.

fn children_bi(&self) -> VecDeque<To>

Returns the children of a type. If to == from then it returns the original element (in contrast to children).

fn transform_bi(&self, op: &impl Fn(To) -> To) -> Self

Applies the given function to all nodes bottom up.

fn holes_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over all direct children of the input, paired with a function that “fills the hole” where the child was with a new value.

fn contexts_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over the universe of the input, paired with a function that “fills the hole” where the child was with a new value.

impl Biplate<UnresolvedDomain> for Domain

fn biplate( &self, ) -> (Tree<UnresolvedDomain>, Box<dyn Fn(Tree<UnresolvedDomain>) -> Domain>)

Definition of a Biplate.

fn with_children_bi(&self, children: VecDeque<To>) -> Self

Reconstructs the node with the given children.

fn descend_bi(&self, op: &impl Fn(To) -> To) -> Self

Biplate variant of [Uniplate::descend]

fn universe_bi(&self) -> VecDeque<To>

Gets all children of a node, including itself and all children.

fn children_bi(&self) -> VecDeque<To>

Returns the children of a type. If to == from then it returns the original element (in contrast to children).

fn transform_bi(&self, op: &impl Fn(To) -> To) -> Self

Applies the given function to all nodes bottom up.

fn holes_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over all direct children of the input, paired with a function that “fills the hole” where the child was with a new value.

fn contexts_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over the universe of the input, paired with a function that “fills the hole” where the child was with a new value.

impl Clone for Domain

fn clone(&self) -> Domain

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Domain

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Domain

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Domain

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

Formats the value using the given formatter.

impl Hash for Domain

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 PartialEq for Domain

fn eq(&self, other: &Domain) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Quine for Domain

fn ctor_tokens(&self) -> TokenStream

impl Serialize for Domain

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Typeable for Domain

fn return_type(&self) -> ReturnType

impl Uniplate for Domain

fn uniplate(&self) -> (Tree<Domain>, Box<dyn Fn(Tree<Domain>) -> Domain>)

Definition of a Uniplate.

fn descend(&self, op: &impl Fn(Self) -> Self) -> Self

Applies a function to all direct children of this

fn universe(&self) -> VecDeque<Self>

Gets all children of a node, including itself and all children.

fn children(&self) -> VecDeque<Self>

Gets the direct children (maximal substructures) of a node.

fn with_children(&self, children: VecDeque<Self>) -> Self

Reconstructs the node with the given children.

fn transform(&self, f: &impl Fn(Self) -> Self) -> Self

Applies the given function to all nodes bottom up.

fn rewrite(&self, f: &impl Fn(Self) -> Option<Self>) -> Self

Rewrites by applying a rule everywhere it can.

fn cata<T>(&self, op: &impl Fn(Self, VecDeque<T>) -> T) -> T

Performs a fold-like computation on each value.

fn holes(&self) -> impl Iterator<Item = (Self, impl Fn(Self))>

Returns an iterator over all direct children of the input, paired with a function that “fills the hole” where the child was with a new value.

fn contexts(&self) -> impl Iterator<Item = (Self, impl Fn(Self))>

Returns an iterator over the universe of the input, paired with a function that “fills the hole” where the child was with a new value.

impl Eq for Domain

impl StructuralPartialEq for Domain

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes

Size for each variant:

• Ground: 8 bytes
• Unresolved: 8 bytes