Enum ACOperatorKind 

pub enum ACOperatorKind {
    And,
    Or,
    Product,
    Sum,
    Min,
    Max,
}

The possible kinds of associative-commutative (AC) operator.

AC operators take a single vector as input and are commonly used alongside comprehensions.

Min/Max are included here for the sole purpose of tagging a comprehension’s skip_operator so that a symbolic guard inside min([... | ...])/max([... | ...]) can be lowered correctly by the native comprehension expander – unlike And/Or/Sum/Product, they have no universal identity element (the “safe value to substitute for a guarded-out element” depends on the element’s own domain), so identity is intentionally unreachable for them; callers that might see a Min/Max operator must check for that first (see expand_native.rs’s guard on the identity-dropping optimisation for the only current example). They are deliberately not wired into TryFrom<&Expression> or the AC-comprehension merge/ via-solver machinery, which only ever handles the four true AC operators.

Variants

And

Or

Product

Sum

Min

Max

Implementations

impl ACOperatorKind

pub fn as_expression(&self, child_expr: Expression) -> Expression

Creates a new Expression of this AC operator kind with the given child expression.

The child expression given should be of type matrix.

pub fn identity(&self) -> Literal

Returns the identity element of this operation.

Example

use conjure_cp_core::ast::{ac_operators::ACOperatorKind,Literal};

let identity = ACOperatorKind::And.identity();
assert_eq!(identity,Literal::Bool(true));

Panics

Min/Max have no universal identity element – see the type-level doc comment. Callers must not call this for those two variants.

pub fn make_skip_operation( &self, guard_expr: Expression, tail_expr: Expression, ) -> Expression

Given some guard and tail expressions, constructs the skipping operator for this operation.

The skipping operator is operator that takes some boolean guard expression b and some tail expression x. If b is true, then it evaluates to x, otherwise it evaluates to the identity element.

Usage

This can be used to add guards to elements of AC operations. In the example model below, we only want to multiply y*z by 2 if multiplyByTwo is true:

find multiplyByTwo: bool
find x: int(1..5)
find y: int(1..5)
find z: int(1..5)

such that
  
x = product([y,z,[1,x;int(0..1)][toInt(b)]])

[1,x;int(0..1)][toInt(b)] is the skipping operator for product.

This method constructs the skipping operator, substituting in the given expressions for b and x.

pub fn make_min_max_skip_operation( &self, guard_expr: Expression, tail_expr: Expression, skip_value: Literal, ) -> Expression

The min/max equivalent of make_skip_operation: self must be Min or Max. Unlike the four true AC operators, min/max have no value that’s always safe to substitute for a guarded-out element – callers must supply one themselves (skip_value), since this method has no way to know it: by the time a per-branch skip operation is being built, tail_expr is already the branch-specific (and so potentially far too narrow) result, not the comprehension’s general return-expression domain the skip value should come from. Any domain bound safe for every element being aggregated works (e.g. the element’s declared domain’s max, for min, or min, for max) – including it can never change a min/max computed over at least one included real element, since it is never more extreme than any value the element could actually take.

pub fn return_type(&self) -> ReturnType

Gives the return type of the operator, and the return types its elements should be.

Trait Implementations

impl Clone for ACOperatorKind

fn clone(&self) -> ACOperatorKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ACOperatorKind

impl Debug for ACOperatorKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ACOperatorKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ACOperatorKind

impl Hash for ACOperatorKind

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 ACOperatorKind

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ACOperatorKind

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 StructuralPartialEq for ACOperatorKind

impl TryFrom<&Expression> for ACOperatorKind

type Error = ()

The type returned in the event of a conversion error.

fn try_from( expr: &Expression, ) -> Result<ACOperatorKind, <ACOperatorKind as TryFrom<&Expression>>::Error>

Performs the conversion.

impl TryFrom<Box<Expression>> for ACOperatorKind

type Error = ()

The type returned in the event of a conversion error.

fn try_from( value: Box<Expression>, ) -> Result<ACOperatorKind, <ACOperatorKind as TryFrom<Box<Expression>>>::Error>

Performs the conversion.

impl TryFrom<Expression> for ACOperatorKind

type Error = ()

The type returned in the event of a conversion error.

fn try_from( value: Expression, ) -> Result<ACOperatorKind, <ACOperatorKind as TryFrom<Expression>>::Error>

Performs the conversion.

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: 1 byte

Size for each variant:

• And: 0 bytes
• Or: 0 bytes
• Product: 0 bytes
• Sum: 0 bytes
• Min: 0 bytes
• Max: 0 bytes