Enum Domain

pub enum Domain {
    Bool,
    Int(Vec<Range<i32>>),
    Empty(ReturnType),
    Reference(Name),
    Set(SetAttr, Box<Domain>),
    Matrix(Box<Domain>, Vec<Domain>),
    Tuple(Vec<Domain>),
    Record(Vec<RecordEntry>),
}

Variants

Bool

Int(Vec<Range<i32>>)

An integer domain.

• If multiple ranges are inside the domain, the values in the domain are the union of these ranges.

• If no ranges are given, the int domain is considered unconstrained, and can take any integer value.

Empty(ReturnType)

An empty domain of the given type.

Reference(Name)

Set(SetAttr, Box<Domain>)

Matrix(Box<Domain>, Vec<Domain>)

A n-dimensional matrix with a value domain and n-index domains

Tuple(Vec<Domain>)

Record(Vec<RecordEntry>)

Implementations

impl Domain

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

Returns true if lit is a member of the domain.

Errors

• DomainOpError::InputContainsReference if the input domain is a reference or contains a reference, meaning that its members cannot be determined.

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

Returns a list of all possible values in the domain.

Errors

• DomainOpError::InputNotInteger if the domain is not an integer domain.
• DomainOpError::InputUnbounded if the domain is unbounded.

pub fn from_slice_i32(elements: &[i32]) -> Domain

Creates an Domain::Int containing the given integers.

Domain::from_set_i32 should be used instead where possible, as it is cheaper (it does not need to sort its input).

Examples

use conjure_core::ast::{Domain,Range};

let elements = vec![1,2,3,4,5];

let domain = Domain::from_slice_i32(&elements);

let Domain::Int(ranges) = domain else {
    panic!("domain returned from from_slice_i32 should be a Domain::Int");
};

assert_eq!(ranges,vec![Range::Bounded(1,5)]);

use conjure_core::ast::{Domain,Range};

let elements = vec![1,2,4,5,7,8,9,10];

let domain = Domain::from_slice_i32(&elements);

let Domain::Int(ranges) = domain else {
    panic!("domain returned from from_slice_i32 should be a Domain::Int");
};

assert_eq!(ranges,vec![Range::Bounded(1,2),Range::Bounded(4,5),Range::Bounded(7,10)]);

use conjure_core::ast::{Domain,Range,ReturnType};

let elements = vec![];

let domain = Domain::from_slice_i32(&elements);

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

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

Creates an Domain::Int containing the given integers.

Examples

use conjure_core::ast::{Domain,Range};
use std::collections::BTreeSet;

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

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

let Domain::Int(ranges) = domain else {
    panic!("domain returned from from_slice_i32 should be a Domain::Int");
};

assert_eq!(ranges,vec![Range::Bounded(1,5)]);

use conjure_core::ast::{Domain,Range};
use std::collections::BTreeSet;

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

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

let Domain::Int(ranges) = domain else {
    panic!("domain returned from from_set_i32 should be a Domain::Int");
};

assert_eq!(ranges,vec![Range::Bounded(1,2),Range::Bounded(4,5),Range::Bounded(7,10)]);

use conjure_core::ast::{Domain,Range,ReturnType};
use std::collections::BTreeSet;

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

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

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

pub fn values(&self) -> Result<Vec<Literal>, DomainOpError>

Gets all the Literal values inside this domain.

Errors

• DomainOpError::InputNotInteger if the domain is not an integer domain.
• DomainOpError::InputContainsReference if the domain is a reference or contains a reference, meaning that its values cannot be determined.

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

Gets the length of this domain.

Errors

• DomainOpError::InputUnbounded if the input domain is of infinite size.
• DomainOpError::InputContainsReference if the input domain is or contains a domain reference, meaning that its size cannot be determined.

pub fn apply_i32( &self, op: fn(i32, i32) -> Option<i32>, other: &Domain, ) -> Result<Domain, 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::InputUnbounded if either of the input domains are unbounded.
• DomainOpError::InputNotInteger if either of the input domains are not integers.

pub fn is_finite(&self) -> Result<bool, DomainOpError>

Returns true if the domain is finite.

Errors

• DomainOpError::InputContainsReference if the input domain is or contains a domain reference, meaning that its size cannot be determined.

pub fn resolve(self, symbols: &SymbolTable) -> Domain

Resolves this domain to a ground domain, using the symbol table provided to resolve references.

A domain is ground iff it is not a domain reference, nor contains any domain references.

See also: SymbolTable::resolve_domain.

Panics

• If a reference domain in self does not exist in the given symbol table.

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

Calculates the intersection of two domains.

Errors

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

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

Calculates the union of two domains.

Errors

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

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: Arc<dyn 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: Arc<dyn Fn(To) -> To>) -> Self

Applies the given function to all nodes bottom up.

fn holes_bi(&self) -> impl Iterator<Item = (To, Arc<dyn Fn(To) -> 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_bi(&self) -> impl Iterator<Item = (To, Arc<dyn Fn(To) -> 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 Clone for Domain

fn clone(&self) -> Domain

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Domain

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

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Domain

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

Formats the value using the given formatter.

impl Hash for Domain

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

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

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

const 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 Serialize for Domain

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

fn return_type(&self) -> Option<ReturnType>

impl Uniplate for Domain

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

Definition of a Uniplate.

fn descend(&self, op: Arc<dyn 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: Arc<dyn Fn(Self) -> Self>) -> Self

Applies the given function to all nodes bottom up.

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

Rewrites by applying a rule everywhere it can.

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

Performs a fold-like computation on each value.

fn holes(&self) -> impl Iterator<Item = (Self, Arc<dyn Fn(Self) -> 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, Arc<dyn Fn(Self) -> 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: 40 bytes

Size for each variant:

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