1 
use conjure_cp::ast::Moo;
2 
// Equals rule for sets
3 
use conjure_cp::ast::Metadata;
4 
use conjure_cp::ast::{Expression, ReturnType::Set, SymbolTable, Typeable};
5 
use conjure_cp::matrix_expr;
6 
use conjure_cp::rule_engine::Reduction;
7 
use conjure_cp::rule_engine::{
8 
    ApplicationError::RuleNotApplicable, ApplicationResult, register_rule,
9 
};
10 

            

        

            

                11
            

            

                
            

            

                
use Expression::{And, Eq, SubsetEq};

            

        

            

                12
            

            

                
            

            

                

            

        

            

                13
            

            

                
            

            

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

            

        

            

                14
            

            

                
            

            

                
fn eq_to_subset_eq(expr: &Expression, _: &SymbolTable) -> ApplicationResult {

            

        

            

                15
            

            

                
            

            

                
    match expr {

            

        

            

                16
            

            

                
            

            

                
        Eq(_, a, b)

            

        

            

                17
            

            

                
            

            

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

            

        

            

                18
            

            

                
            

            

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

            

        

            

                19
            

            

                
            

            

                
        {

            

        

            

                20
            

            

                
            

            

                
            let expr1 = SubsetEq(Metadata::new(), a.clone(), b.clone());

            

        

            

                21
            

            

                
            

            

                
            let expr2 = SubsetEq(Metadata::new(), b.clone(), a.clone());

            

        

            

                22
            

            

                
            

            

                
            Ok(Reduction::pure(And(

            

        

            

                23
            

            

                
            

            

                
                Metadata::new(),

            

        

            

                24
            

            

                
            

            

                
                Moo::new(matrix_expr![expr1, expr2]),

            

        

            

                25
            

            

                
            

            

                
            )))

            

        

            

                26
            

            

                
            

            

                
        }

            

        

            

                27
            

            

                
            

            

                
        _ => Err(RuleNotApplicable),

            

        

            

                28
            

            

                
            

            

                
    }

            

        

            

                29
            

            

                
            

            

                
}