1 
// SupsetEq rule for sets
2 
use conjure_cp::ast::Metadata;
3 
use conjure_cp::ast::{Expression as Expr, ReturnType, SymbolTable, Typeable};
4 
use conjure_cp::rule_engine::Reduction;
5 
use conjure_cp::rule_engine::{
6 
    ApplicationError::RuleNotApplicable, ApplicationResult, register_rule,
7 
};
8 

            

        

            

                9
            

            

                
            

            

                
#[register_rule(("Base", 8700))]

            

        

            

                10
            

            

                
            

            

                
fn supset_eq_to_subset_eq(expr: &Expr, _: &SymbolTable) -> ApplicationResult {

            

        

            

                11
            

            

                
            

            

                
    match expr {

            

        

            

                12
            

            

                
            

            

                
        Expr::SupsetEq(_, a, b)

            

        

            

                13
            

            

                
            

            

                
            if matches!(a.as_ref().return_type(), ReturnType::Set(_))

            

        

            

                14
            

            

                
            

            

                
                && matches!(b.as_ref().return_type(), ReturnType::Set(_)) =>

            

        

            

                15
            

            

                
            

            

                
        {

            

        

            

                16
            

            

                
            

            

                
            Ok(Reduction::pure(Expr::SubsetEq(

            

        

            

                17
            

            

                
            

            

                
                Metadata::new(),

            

        

            

                18
            

            

                
            

            

                
                b.clone(),

            

        

            

                19
            

            

                
            

            

                
                a.clone(),

            

        

            

                20
            

            

                
            

            

                
            )))

            

        

            

                21
            

            

                
            

            

                
        }

            

        

            

                22
            

            

                
            

            

                
        _ => Err(RuleNotApplicable),

            

        

            

                23
            

            

                
            

            

                
    }

            

        

            

                24
            

            

                
            

            

                
}