Enum erg_compiler::ty::predicate::Predicate

pub enum Predicate {
    Value(ValueObj),
    Const(Str),
    Equal {
        lhs: Str,
        rhs: TyParam,
    },
    GreaterEqual {
        lhs: Str,
        rhs: TyParam,
    },
    LessEqual {
        lhs: Str,
        rhs: TyParam,
    },
    NotEqual {
        lhs: Str,
        rhs: TyParam,
    },
    Or(Box<Predicate>, Box<Predicate>),
    And(Box<Predicate>, Box<Predicate>),
    Not(Box<Predicate>),
}

Variants

Value(ValueObj)

Const(Str)

Equal

Fields

lhs: Str

rhs: TyParam

i == 0 => Eq{ lhs: “i”, rhs: 0 }

GreaterEqual

Fields

lhs: Str

rhs: TyParam

i > 0 => i >= 0+ε => GreaterEqual{ lhs: “i”, rhs: 0+ε }

LessEqual

Fields

lhs: Str

rhs: TyParam

NotEqual

Fields

lhs: Str

rhs: TyParam

Or(Box<Predicate>, Box<Predicate>)

And(Box<Predicate>, Box<Predicate>)

Not(Box<Predicate>)

Implementations

impl Predicate

pub const TRUE: Predicate = _

pub const FALSE: Predicate = _

pub const fn eq(lhs: Str, rhs: TyParam) -> Self

pub const fn ne(lhs: Str, rhs: TyParam) -> Self

pub const fn ge(lhs: Str, rhs: TyParam) -> Self

=

pub fn gt(lhs: Str, rhs: TyParam) -> Self

(>= and !=)

pub const fn le(lhs: Str, rhs: TyParam) -> Self

<=

pub fn lt(lhs: Str, rhs: TyParam) -> Self

pub fn and(lhs: Predicate, rhs: Predicate) -> Self

pub fn or(lhs: Predicate, rhs: Predicate) -> Self

pub fn is_equal(&self) -> bool

pub fn consist_of_equal(&self) -> bool

pub fn ands(&self) -> Set<&Predicate>

pub fn ors(&self) -> Set<&Predicate>

pub fn subject(&self) -> Option<&str>

pub fn change_subject_name(self, name: Str) -> Self

pub fn mentions(&self, name: &str) -> bool

pub fn can_be_false(&self) -> bool

pub fn qvars(&self) -> Set<(Str, Constraint)>

pub fn has_qvar(&self) -> bool

pub fn has_unbound_var(&self) -> bool

pub fn min_max<'a>( &'a self, min: Option<&'a TyParam>, max: Option<&'a TyParam> ) -> (Option<&'a TyParam>, Option<&'a TyParam>)

pub fn typarams(&self) -> Vec<&TyParam>

pub fn typarams_mut(&mut self) -> Vec<&mut TyParam>

pub fn invert(self) -> Self

Trait Implementations

impl BitAnd<Predicate> for Predicate

type Output = Predicate

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitOr<Predicate> for Predicate

type Output = Predicate

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl Clone for Predicate

fn clone(&self) -> Predicate

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Predicate

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

Formats the value using the given formatter.

impl Display for Predicate

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

Formats the value using the given formatter.

impl HasLevel for Predicate

fn level(&self) -> Option<usize>

fn set_level(&self, level: usize)

fn lower(&self, level: Level)

fn lift(&self)

fn generalize(&self)

fn is_generalized(&self) -> bool

impl Hash for Predicate

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 Not for Predicate

type Output = Predicate

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq<Predicate> for Predicate

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Predicate

impl StructuralEq for Predicate

impl StructuralPartialEq for Predicate