Enum GroundDomain 

pub enum GroundDomain {
    Empty(ReturnType),
    Bool,
    Int(Vec<Range<i32>>),
    Set(SetAttr<i32>, Moo<GroundDomain>),
    Matrix(Moo<GroundDomain>, Vec<Moo<GroundDomain>>),
    Tuple(Vec<Moo<GroundDomain>>),
    Record(Vec<RecordEntryGround>),
    Function(FuncAttr, Moo<GroundDomain>, Moo<GroundDomain>),
}

Variants

Empty(ReturnType)

An empty domain of a given type

Bool

A boolean value (true / false)

Int(Vec<Range<i32>>)

An integer value in the given ranges (e.g. int(1, 3..5))

Set(SetAttr<i32>, Moo<GroundDomain>)

A set of elements drawn from the inner domain

Matrix(Moo<GroundDomain>, Vec<Moo<GroundDomain>>)

An N-dimensional matrix of elements drawn from the inner domain, and indices from the n index domains

Tuple(Vec<Moo<GroundDomain>>)

A tuple of N elements, each with its own domain

Record(Vec<RecordEntryGround>)

A record

Function(FuncAttr, Moo<GroundDomain>, Moo<GroundDomain>)

A function with a domain and range

Implementations

impl GroundDomain

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

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

Calculates the intersection of two domains.

Errors

• DomainOpError::Unbounded if either of the input domains are unbounded.
• DomainOpError::WrongType if the input domains are different types, or are not integer or set domains.

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

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

Gets the length of this domain.

Errors

• DomainOpError::Unbounded if the input domain is of infinite size.

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

pub fn values_i32(&self) -> Result<Vec<i32>, DomainOpError>

Returns a list of all possible values in an integer domain.

Errors

• DomainOpError::NotInteger if the domain is not an integer domain.
• DomainOpError::Unbounded if the domain is unbounded.

pub fn from_set_i32(elements: &BTreeSet<i32>) -> GroundDomain

Creates an [Domain::Int] containing the given integers.

Examples

use conjure_cp_core::ast::{GroundDomain, Range};
use conjure_cp_core::{domain_int_ground,range};
use std::collections::BTreeSet;

let elements = BTreeSet::from([1,2,3,4,5]);

let domain = GroundDomain::from_set_i32(&elements);

assert_eq!(domain,domain_int_ground!(1..5));

use conjure_cp_core::ast::{GroundDomain,Range};
use conjure_cp_core::{domain_int_ground,range};
use std::collections::BTreeSet;

let elements = BTreeSet::from([1,2,4,5,7,8,9,10]);

let domain = GroundDomain::from_set_i32(&elements);

assert_eq!(domain,domain_int_ground!(1..2,4..5,7..10));

use conjure_cp_core::ast::{GroundDomain,Range,ReturnType};
use std::collections::BTreeSet;

let elements = BTreeSet::from([]);

let domain = GroundDomain::from_set_i32(&elements);

assert!(matches!(domain,GroundDomain::Empty(ReturnType::Int)))

pub fn apply_i32( &self, op: fn(i32, i32) -> Option<i32>, other: &GroundDomain, ) -> Result<GroundDomain, DomainOpError>

Returns the domain that is the result of applying a binary operation to two integer domains.

The given operator may return None if the operation is not defined for its arguments. Undefined values will not be included in the resulting domain.

Errors

• DomainOpError::Unbounded if either of the input domains are unbounded.
• DomainOpError::NotInteger if either of the input domains are not integers.

pub fn is_finite(&self) -> bool

Returns true if the domain is finite.

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

For a vector of literals, creates a domain that contains all the elements.

The literals must all be of the same type.

For abstract literals, this method merges the element domains of the literals, but not the index domains. Thus, for fixed-sized abstract literals (matrices, tuples, records, etc.), all literals in the vector must also have the same size / index domain:

• Matrices: all literals must have the same index domain.
• Tuples: all literals must have the same number of elements.
• Records: all literals must have the same fields.

Errors

• DomainOpError::WrongType if the input literals are of a different type to each-other, as described above.

Examples

use conjure_cp_core::ast::{Range, Literal, ReturnType, GroundDomain};

let domain = GroundDomain::from_literal_vec(&vec![]);
assert_eq!(domain,Ok(GroundDomain::Empty(ReturnType::Unknown)));

use conjure_cp_core::ast::{GroundDomain,Range,Literal, AbstractLiteral};
use conjure_cp_core::{domain_int_ground, range, matrix};

// `[1,2;int(2..3)], [4,5; int(2..3)]` has domain
// `matrix indexed by [int(2..3)] of int(1..2,4..5)`

let matrix_1 = Literal::AbstractLiteral(matrix![Literal::Int(1),Literal::Int(2);domain_int_ground!(2..3)]);
let matrix_2 = Literal::AbstractLiteral(matrix![Literal::Int(4),Literal::Int(5);domain_int_ground!(2..3)]);

let domain = GroundDomain::from_literal_vec(&vec![matrix_1,matrix_2]);

let expected_domain = Ok(GroundDomain::Matrix(
    domain_int_ground!(1..2,4..5),vec![domain_int_ground!(2..3)]));

assert_eq!(domain,expected_domain);

use conjure_cp_core::ast::{GroundDomain,Range,Literal, AbstractLiteral,DomainOpError};
use conjure_cp_core::{domain_int_ground, range, matrix};

// `[1,2;int(2..3)], [4,5; int(1..2)]` cannot be combined
// `matrix indexed by [int(2..3)] of int(1..2,4..5)`

let matrix_1 = Literal::AbstractLiteral(matrix![Literal::Int(1),Literal::Int(2);domain_int_ground!(2..3)]);
let matrix_2 = Literal::AbstractLiteral(matrix![Literal::Int(4),Literal::Int(5);domain_int_ground!(1..2)]);

let domain = GroundDomain::from_literal_vec(&vec![matrix_1,matrix_2]);

assert_eq!(domain,Err(DomainOpError::WrongType));

use conjure_cp_core::ast::{GroundDomain,Range,Literal, AbstractLiteral};
use conjure_cp_core::{domain_int_ground,range, matrix};

// `[[1,2; int(1..2)];int(2)], [[4,5; int(1..2)]; int(2)]` has domain
// `matrix indexed by [int(2),int(1..2)] of int(1..2,4..5)`


let matrix_1 = Literal::AbstractLiteral(matrix![Literal::AbstractLiteral(matrix![Literal::Int(1),Literal::Int(2);domain_int_ground!(1..2)]); domain_int_ground!(2)]);
let matrix_2 = Literal::AbstractLiteral(matrix![Literal::AbstractLiteral(matrix![Literal::Int(4),Literal::Int(5);domain_int_ground!(1..2)]); domain_int_ground!(2)]);

let domain = GroundDomain::from_literal_vec(&vec![matrix_1,matrix_2]);

let expected_domain = Ok(GroundDomain::Matrix(
    domain_int_ground!(1..2,4..5),
    vec![domain_int_ground!(2),domain_int_ground!(1..2)]));

assert_eq!(domain,expected_domain);

Trait Implementations

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<GroundDomain> for GroundDomain

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

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 GroundDomain

fn clone(&self) -> GroundDomain

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GroundDomain

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GroundDomain

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for GroundDomain

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

Formats the value using the given formatter.

impl From<GroundDomain> for DomainPtr

fn from(value: GroundDomain) -> Self

Converts to this type from the input type.

impl Hash for GroundDomain

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 GroundDomain

fn eq(&self, other: &GroundDomain) -> 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 GroundDomain

fn ctor_tokens(&self) -> TokenStream

impl Serialize for GroundDomain

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 GroundDomain

fn return_type(&self) -> ReturnType

impl Uniplate for GroundDomain

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

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 GroundDomain

impl StructuralPartialEq for GroundDomain

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: 40 bytes

Size for each variant:

• Empty: 36 bytes
• Bool: 0 bytes
• Int: 28 bytes
• Set: 20 bytes
• Matrix: 36 bytes
• Tuple: 28 bytes
• Record: 28 bytes
• Function: 36 bytes