adding comments

Author: mmatera

mathics/core/rules.py

@@ -19,6 +19,10 @@ def function_arguments(f):
     return _python_function_arguments(f)
 
 
+class StopMatchConditionFailed(StopGenerator):
+    pass
+
+
 class StopGenerator_BaseRule(StopGenerator):
     pass
 
@@ -59,7 +63,11 @@ def yield_match(vars, rest):
                 if name.startswith("_option_"):
                     options[name[len("_option_") :]] = value
                     del vars[name]
-            new_expression = self.do_replace(expression, vars, options, evaluation)
+            try:
+                new_expression = self.do_replace(expression, vars, options, evaluation)
+            except StopMatchConditionFailed:
+                return
+
             if new_expression is None:
                 new_expression = expression
             if rest[0] or rest[1]:
@@ -107,7 +115,7 @@ def yield_match(vars, rest):
     def do_replace(self):
         raise NotImplementedError
 
-    def get_sort_key(self) -> tuple:
+    def get_sort_key(self, pattern_sort=False) -> tuple:
         # FIXME: check if this makes sense:
         return tuple((self.system, self.pattern.get_sort_key(True)))
 
@@ -131,20 +139,128 @@ class Rule(BaseRule):
     ``G[1.^2, a^2]``
     """
 
+    def __ge__(self, other):
+        if isinstance(other, Rule):
+            sys, key, rhs_cond = self.get_sort_key()
+            sys_other, key_other, rhs_cond_other = other.get_sort_key()
+            if sys != sys_other:
+                return sys > sys_other
+            if key != key_other:
+                return key > key_other
+
+            # larger and more complex conditions come first
+            len_cond, len_cond_other = len(rhs_cond), len(rhs_cond_other)
+            if len_cond != len_cond_other:
+                return len_cond_other > len_cond
+            if len_cond == 0:
+                return False
+            for me_cond, other_cond in zip(rhs_cond, rhs_cond_other):
+                me_sk = me_cond.get_sort_key(True)
+                o_sk = other_cond.get_sort_key(True)
+                if me_sk > o_sk:
+                    return False
+            return True
+        # Follow the usual rule
+        return self.get_sort_key(True) >= other.get_sort_key(True)
+
+    def __gt__(self, other):
+        if isinstance(other, Rule):
+            sys, key, rhs_cond = self.get_sort_key()
+            sys_other, key_other, rhs_cond_other = other.get_sort_key()
+            if sys != sys_other:
+                return sys > sys_other
+            if key != key_other:
+                return key > key_other
+
+            # larger and more complex conditions come first
+            len_cond, len_cond_other = len(rhs_cond), len(rhs_cond_other)
+            if len_cond != len_cond_other:
+                return len_cond_other > len_cond
+            if len_cond == 0:
+                return False
+
+            for me_cond, other_cond in zip(rhs_cond, rhs_cond_other):
+                me_sk = me_cond.get_sort_key(True)
+                o_sk = other_cond.get_sort_key(True)
+                if me_sk > o_sk:
+                    return False
+            return me_sk > o_sk
+        # Follow the usual rule
+        return self.get_sort_key(True) > other.get_sort_key(True)
+
+    def __le__(self, other):
+        if isinstance(other, Rule):
+            sys, key, rhs_cond = self.get_sort_key()
+            sys_other, key_other, rhs_cond_other = other.get_sort_key()
+            if sys != sys_other:
+                return sys < sys_other
+            if key != key_other:
+                return key < key_other
+
+            # larger and more complex conditions come first
+            len_cond, len_cond_other = len(rhs_cond), len(rhs_cond_other)
+            if len_cond != len_cond_other:
+                return len_cond_other < len_cond
+            if len_cond == 0:
+                return False
+            for me_cond, other_cond in zip(rhs_cond, rhs_cond_other):
+                me_sk = me_cond.get_sort_key(True)
+                o_sk = other_cond.get_sort_key(True)
+                if me_sk < o_sk:
+                    return False
+            return True
+        # Follow the usual rule
+        return self.get_sort_key(True) <= other.get_sort_key(True)
+
+    def __lt__(self, other):
+        if isinstance(other, Rule):
+            sys, key, rhs_cond = self.get_sort_key()
+            sys_other, key_other, rhs_cond_other = other.get_sort_key()
+            if sys != sys_other:
+                return sys < sys_other
+            if key != key_other:
+                return key < key_other
+
+            # larger and more complex conditions come first
+            len_cond, len_cond_other = len(rhs_cond), len(rhs_cond_other)
+            if len_cond != len_cond_other:
+                return len_cond_other < len_cond
+            if len_cond == 0:
+                return False
+
+            for me_cond, other_cond in zip(rhs_cond, rhs_cond_other):
+                me_sk = me_cond.get_sort_key(True)
+                o_sk = other_cond.get_sort_key(True)
+                if me_sk < o_sk:
+                    return False
+            return me_sk > o_sk
+        # Follow the usual rule
+        return self.get_sort_key(True) < other.get_sort_key(True)
+
     def __init__(self, pattern, replace, delayed=True, system=False) -> None:
         super(Rule, self).__init__(pattern, system=system)
         self.replace = replace
         self.delayed = delayed
-
-    def do_replace(self, expression, vars, options, evaluation):
-        replace = self.replace
-        if self.delayed:
+        # If delayed is True, and replace is a nested
+        # Condition expression, stores the conditions and the
+        # remaining stripped expression.
+        # This is going to be used to compare and sort rules,
+        # and also to decide if the rule matches an expression.
+        conds = []
+        if delayed:
             while replace.has_form("System`Condition", 2):
                 replace, cond = replace.elements
-                cond = cond.replace_vars(vars)
-                cond = cond.evaluate(evaluation)
-                if cond is not SymbolTrue:
-                    return None
+                conds.append(cond)
+            self.rhs_conditions = sorted(conds)
+            self.strip_replace = replace
+
+    def do_replace(self, expression, vars, options, evaluation):
+        replace = self.replace if self.rhs_conditions == [] else self.strip_replace
+        for cond in self.rhs_conditions:
+            cond = cond.replace_vars(vars)
+            cond = cond.evaluate(evaluation)
+            if cond is not SymbolTrue:
+                raise StopMatchConditionFailed
 
         new = replace.replace_vars(vars)
         new.options = options
@@ -169,6 +285,12 @@ def do_replace(self, expression, vars, options, evaluation):
     def __repr__(self) -> str:
         return "<Rule: %s -> %s>" % (self.pattern, self.replace)
 
+    def get_sort_key(self, pattern_sort=False) -> tuple:
+        # FIXME: check if this makes sense:
+        return tuple(
+            (self.system, self.pattern.get_sort_key(True), self.rhs_conditions)
+        )
+
 
 class BuiltinRule(BaseRule):
     """

mathics/core/systemsymbols.py

@@ -169,6 +169,7 @@
 SymbolSeries = Symbol("System`Series")
 SymbolSeriesData = Symbol("System`SeriesData")
 SymbolSet = Symbol("System`Set")
+SymbolSetDelayed = Symbol("System`SetDelayed")
 SymbolSign = Symbol("System`Sign")
 SymbolSimplify = Symbol("System`Simplify")
 SymbolSin = Symbol("System`Sin")
@@ -186,6 +187,8 @@
 SymbolSubsuperscriptBox = Symbol("System`SubsuperscriptBox")
 SymbolSuperscriptBox = Symbol("System`SuperscriptBox")
 SymbolTable = Symbol("System`Table")
+SymbolTagSet = Symbol("System`TagSet")
+SymbolTagSetDelayed = Symbol("System`TagSetDelayed")
 SymbolTeXForm = Symbol("System`TeXForm")
 SymbolThrow = Symbol("System`Throw")
 SymbolToString = Symbol("System`ToString")
@@ -194,5 +197,7 @@
 SymbolUndefined = Symbol("System`Undefined")
 SymbolUnequal = Symbol("System`Unequal")
 SymbolUnevaluated = Symbol("System`Unevaluated")
+SymbolUpSet = Symbol("System`UpSet")
+SymbolUpSetDelayed = Symbol("System`UpSetDelayed")
 SymbolUpValues = Symbol("System`UpValues")
 SymbolXor = Symbol("System`Xor")

test/test_control.py

@@ -69,7 +69,7 @@ def test_condition():
     evaluate(
         """
         (* Define a function that can "throw an exception": *)
-
+         ClearAll[f];
          f[x_] := ppp[x]/; x>0
         """
     )