Enum Predicate

pub enum Predicate {
    Value(ValueObj),
    Const(Str),
    Call {
        receiver: TyParam,
        name: Option<Str>,
        args: Vec<TyParam>,
    },
    Attr {
        receiver: TyParam,
        name: Str,
    },
    Equal {
        lhs: Str,
        rhs: TyParam,
    },
    GreaterEqual {
        lhs: Str,
        rhs: TyParam,
    },
    LessEqual {
        lhs: Str,
        rhs: TyParam,
    },
    NotEqual {
        lhs: Str,
        rhs: TyParam,
    },
    GeneralEqual {
        lhs: Box<Predicate>,
        rhs: Box<Predicate>,
    },
    GeneralLessEqual {
        lhs: Box<Predicate>,
        rhs: Box<Predicate>,
    },
    GeneralGreaterEqual {
        lhs: Box<Predicate>,
        rhs: Box<Predicate>,
    },
    GeneralNotEqual {
        lhs: Box<Predicate>,
        rhs: Box<Predicate>,
    },
    Or(Set<Predicate>),
    And(Box<Predicate>, Box<Predicate>),
    Not(Box<Predicate>),
    Failure,
}

Variants

Value(ValueObj)

Const(Str)

Call

Fields

receiver: TyParam

name: Option<Str>

args: Vec<TyParam>

Attr

Fields

receiver: TyParam

name: Str

Equal

TODO: unify with GeneralEqual i == 0 => Eq{ lhs: “i”, rhs: 0 }

Fields

lhs: Str

rhs: TyParam

GreaterEqual

i > 0 == i >= 0 and i != 0

Fields

lhs: Str

rhs: TyParam

LessEqual

Fields

lhs: Str

rhs: TyParam

NotEqual

Fields

lhs: Str

rhs: TyParam

GeneralEqual

Fields

lhs: Box<Predicate>

rhs: Box<Predicate>

GeneralLessEqual

Fields

lhs: Box<Predicate>

rhs: Box<Predicate>

GeneralGreaterEqual

Fields

lhs: Box<Predicate>

rhs: Box<Predicate>

GeneralNotEqual

Fields

lhs: Box<Predicate>

rhs: Box<Predicate>

Or(Set<Predicate>)

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

Not(Box<Predicate>)

Failure

Implementations

impl Predicate

pub const TRUE: Predicate

pub const FALSE: Predicate

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

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

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

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

pub fn call(receiver: TyParam, name: Option<Str>, args: Vec<TyParam>) -> Self

pub fn attr(receiver: TyParam, name: Str) -> Self

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 substitute(self, var: &str, tp: &TyParam) -> Self

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

pub fn can_be_false(&self) -> Option<bool>

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

pub fn has_type_satisfies(&self, f: impl Fn(&Type) -> bool + Copy) -> bool

pub fn has_qvar(&self) -> bool

pub fn has_unbound_var(&self) -> bool

pub fn has_undoable_linked_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 invert(self) -> Self

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

pub fn possible_values(&self) -> Vec<&ValueObj>

pub fn variables(&self) -> Set<Str>

pub fn contains_value(&self, value: &ValueObj) -> bool

pub fn contains_tp(&self, tp: &TyParam) -> bool

pub fn contains_t(&self, t: &Type) -> bool

pub fn _replace_tp( self, target: &TyParam, to: &TyParam, tvs: &SharedFrees, ) -> Self

pub fn replace_tp(self, target: &TyParam, to: &TyParam) -> Self

pub fn _replace_t(self, target: &Type, to: &Type, tvs: &SharedFrees) -> Self

pub fn dereference(&mut self)

pub fn map_t(self, f: &mut impl FnMut(Type) -> Type, tvs: &SharedFrees) -> Self

pub fn map_tp( self, f: &mut impl FnMut(TyParam) -> TyParam, tvs: &SharedFrees, ) -> Self

pub fn try_map_tp<E>( self, f: &mut impl FnMut(TyParam) -> Result<TyParam, E>, tvs: &SharedFrees, ) -> Result<Self, E>

Trait Implementations

impl BitAnd for Predicate

type Output = Predicate

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitOr 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 duplicate 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 Default for Predicate

fn default() -> Predicate

Returns the “default value” for a type.

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 set_lower(&self, level: Level)

fn lift(&self)

fn lower(&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 LimitedDisplay for Predicate

fn limited_fmt<W: Write>(&self, f: &mut W, limit: isize) -> Result

If limit was set to a negative value, it will be displayed without abbreviation. FIXME:

fn to_string_unabbreviated(&self) -> String

const DEFAULT_LIMIT: isize = 10isize

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

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

fn structural_eq(&self, other: &Self) -> bool

impl Eq for Predicate

impl Immutable for Predicate

impl StructuralPartialEq for Predicate