Struct DeclarationPtr 

pub struct DeclarationPtr { /* private fields */ }

A shared pointer to a [Declaration].

Two declaration pointers are equal if they point to the same underlying declaration.

Id

The id of DeclarationPtr obeys the following invariants:

1. Declaration pointers have the same id if they point to the same underlying declaration.

2. The id is immutable.

3. Changing the declaration pointed to by the declaration pointer does not change the id. This allows declarations to be updated by replacing them with a newer version of themselves.

Ord, Hash, and Eq use id for comparisons.

Serde

Declaration pointers can be serialised using the following serializers:

• DeclarationPtrFull
• DeclarationPtrAsId

See their documentation for more information.

Implementations

impl DeclarationPtr

pub fn new(name: Name, kind: DeclarationKind) -> DeclarationPtr

Creates a new declaration.

Examples

use conjure_cp_core::ast::{DeclarationPtr,Name,DeclarationKind,Domain,Range};

// letting MyDomain be int(1..5)
let declaration = DeclarationPtr::new(
    Name::User("MyDomain".into()),
    DeclarationKind::DomainLetting(Domain::Int(vec![
        Range::Bounded(1,5)])));

pub fn new_var(name: Name, domain: Domain) -> DeclarationPtr

Creates a new decision variable declaration with the decision category.

Examples

use conjure_cp_core::ast::{DeclarationPtr,Name,DeclarationKind,Domain,Range};

// find x: int(1..5)
let declaration = DeclarationPtr::new_var(
    Name::User("x".into()),
    Domain::Int(vec![Range::Bounded(1,5)]));

pub fn new_var_quantified(name: Name, domain: Domain) -> DeclarationPtr

Creates a new decision variable with the quantified category.

This is useful to represent a quantified / induction variable in a comprehension.

pub fn new_domain_letting(name: Name, domain: Domain) -> DeclarationPtr

Creates a new domain letting declaration.

Examples

use conjure_cp_core::ast::{DeclarationPtr,Name,DeclarationKind,Domain,Range};

// letting MyDomain be int(1..5)
let declaration = DeclarationPtr::new_domain_letting(
    Name::User("MyDomain".into()),
    Domain::Int(vec![Range::Bounded(1,5)]));

pub fn new_value_letting(name: Name, expression: Expression) -> DeclarationPtr

Creates a new value letting declaration.

Examples

use conjure_cp_core::ast::{DeclarationPtr,Name,DeclarationKind,Domain,Range, Expression,
Literal,Atom,Moo};
use conjure_cp_core::{matrix_expr,metadata::Metadata};

// letting n be 10 + 10
let ten = Expression::Atomic(Metadata::new(),Atom::Literal(Literal::Int(10)));
let expression = Expression::Sum(Metadata::new(),Moo::new(matrix_expr![ten.clone(),ten]));
let declaration = DeclarationPtr::new_value_letting(
    Name::User("n".into()),
    expression);

pub fn new_given(name: Name, domain: Domain) -> DeclarationPtr

Creates a new given declaration.

Examples

use conjure_cp_core::ast::{DeclarationPtr,Name,DeclarationKind,Domain,Range};

// given n: int(1..5)
let declaration = DeclarationPtr::new_given(
    Name::User("n".into()),
    Domain::Int(vec![Range::Bounded(1,5)]));

pub fn new_record_field(entry: RecordEntry) -> DeclarationPtr

Creates a new record field declaration.

Examples

use conjure_cp_core::ast::{DeclarationPtr,Name,records::RecordEntry,Domain,Range};

// create declaration for field A in `find rec: record {A: int(0..1), B: int(0..2)}`

let field = RecordEntry {
    name: Name::User("n".into()),
    domain: Domain::Int(vec![Range::Bounded(1,5)])
};

let declaration = DeclarationPtr::new_record_field(field);

pub fn domain(&self) -> Option<Domain>

Gets the domain of the declaration, if it has one.

Examples

use conjure_cp_core::ast::{DeclarationPtr,Name,Domain,Range};

// find a: int(1..5)
let declaration = DeclarationPtr::new_var(Name::User("a".into()),Domain::Int(vec![Range::Bounded(1,5)]));

assert!(declaration.domain().is_some_and(|x| x == Domain::Int(vec![Range::Bounded(1,5)])))

pub fn kind(&self) -> Ref<'_, DeclarationKind>

Gets the kind of the declaration.

Examples

use conjure_cp_core::ast::{DeclarationPtr,DeclarationKind,Name,Domain,Range};

// find a: int(1..5)
let declaration = DeclarationPtr::new_var(Name::User("a".into()),Domain::Int(vec![Range::Bounded(1,5)]));
assert!(matches!(&declaration.kind() as &DeclarationKind, DeclarationKind::DecisionVariable(_)))

pub fn name(&self) -> Ref<'_, Name>

Gets the name of the declaration.

Examples

use conjure_cp_core::ast::{DeclarationPtr,Name,Domain,Range};

// find a: int(1..5)
let declaration = DeclarationPtr::new_var(Name::User("a".into()),Domain::Int(vec![Range::Bounded(1,5)]));

assert_eq!(&declaration.name() as &Name, &Name::User("a".into()))

pub fn as_var(&self) -> Option<Ref<'_, DecisionVariable>>

This declaration as a decision variable, if it is one.

pub fn as_var_mut(&mut self) -> Option<RefMut<'_, DecisionVariable>>

This declaration as a mutable decision variable, if it is one.

pub fn as_domain_letting(&self) -> Option<Ref<'_, Domain>>

This declaration as a domain letting, if it is one.

pub fn as_domain_letting_mut(&mut self) -> Option<RefMut<'_, Domain>>

This declaration as a mutable domain letting, if it is one.

pub fn as_value_letting(&self) -> Option<Ref<'_, Expression>>

This declaration as a value letting, if it is one.

pub fn as_value_letting_mut(&mut self) -> Option<RefMut<'_, Expression>>

This declaration as a mutable value letting, if it is one.

pub fn replace_name(&mut self, name: Name) -> Name

Changes the name in this declaration, returning the old one.

Examples

use conjure_cp_core::ast::{DeclarationPtr, Domain, Range, Name};

// find a: int(1..5)
let mut declaration = DeclarationPtr::new_var(Name::User("a".into()),Domain::Int(vec![Range::Bounded(1,5)]));

let old_name = declaration.replace_name(Name::User("b".into()));
assert_eq!(old_name,Name::User("a".into()));
assert_eq!(&declaration.name() as &Name,&Name::User("b".into()));

pub fn detach(self) -> DeclarationPtr

Creates a new declaration pointer with the same contents as self that is not shared with anyone else.

As the resulting pointer is unshared, it will have a new id.

Examples

use conjure_cp_core::ast::{DeclarationPtr,Name,Domain,Range};

// find a: int(1..5)
let declaration = DeclarationPtr::new_var(Name::User("a".into()),Domain::Int(vec![Range::Bounded(1,5)]));

let mut declaration2 = declaration.clone();

declaration2.replace_name(Name::User("b".into()));

assert_eq!(&declaration.name() as &Name, &Name::User("b".into()));
assert_eq!(&declaration2.name() as &Name, &Name::User("b".into()));

declaration2 = declaration2.detach();

assert_eq!(&declaration2.name() as &Name, &Name::User("b".into()));

declaration2.replace_name(Name::User("c".into()));

assert_eq!(&declaration.name() as &Name, &Name::User("b".into()));
assert_eq!(&declaration2.name() as &Name, &Name::User("c".into()));

Trait Implementations

impl Biplate<DeclarationPtr> for Atom

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

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<DeclarationPtr> for DeclarationKind

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

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<DeclarationPtr> for Expression

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

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<To> Biplate<To> for DeclarationPtr

where Declaration: Biplate<To>, To: Uniplate,

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

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 CategoryOf for DeclarationPtr

fn category_of(&self) -> Category

Gets the Category of a term.

impl Clone for DeclarationPtr

fn clone(&self) -> DeclarationPtr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeclarationPtr

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

Formats the value using the given formatter.

impl DefaultWithId for DeclarationPtr

fn default_with_id(id: u32) -> DeclarationPtr

Creates a new default value of type T, but with the given id.

impl<'de> DeserializeAs<'de, DeclarationPtr> for DeclarationPtrAsId

fn deserialize_as<D>( deserializer: D, ) -> Result<DeclarationPtr, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de> DeserializeAs<'de, DeclarationPtr> for DeclarationPtrFull

fn deserialize_as<D>( deserializer: D, ) -> Result<DeclarationPtr, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DeclarationPtr

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

Formats the value using the given formatter.

impl From<DeclarationPtr> for Atom

fn from(value: DeclarationPtr) -> Atom

Converts to this type from the input type.

impl HasId for DeclarationPtr

fn id(&self) -> u32

The id of this object.

impl Hash for DeclarationPtr

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 Ord for DeclarationPtr

fn cmp(&self, other: &DeclarationPtr) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for DeclarationPtr

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

fn partial_cmp(&self, other: &DeclarationPtr) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl SerializeAs<DeclarationPtr> for DeclarationPtrAsId

fn serialize_as<S>( source: &DeclarationPtr, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl SerializeAs<DeclarationPtr> for DeclarationPtrFull

fn serialize_as<S>( source: &DeclarationPtr, 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 DeclarationPtr

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

impl Uniplate for DeclarationPtr

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

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 DeclarationPtr

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