Alternative assignment rework

mathics/builtin/assignments/assignment.py

@@ -4,7 +4,7 @@
 """
 from typing import Optional
 
-from mathics.core.atoms import String
+from mathics.core.atoms import Integer1, String
 from mathics.core.attributes import (
     A_HOLD_ALL,
     A_HOLD_FIRST,
@@ -137,9 +137,9 @@ class Set(InfixOperator):
 
     summary_text = "assign a value"
 
-    def eval(self, lhs, rhs, evaluation):
-        "lhs_ = rhs_"
-
+    def eval(self, expr, evaluation):
+        "Pattern[expr, _ = _]"
+        lhs, rhs = expr.elements
         eval_assign(self, lhs, rhs, evaluation)
         return rhs
 
@@ -217,11 +217,9 @@ class SetDelayed(Set):
 
     summary_text = "test a delayed value; used in defining functions"
 
-    def eval(
-        self, lhs: BaseElement, rhs: BaseElement, evaluation: Evaluation
-    ) -> Symbol:
-        "lhs_ := rhs_"
-
+    def eval(self, expr: BaseElement, evaluation: Evaluation) -> Symbol:
+        "Pattern[expr, _ := _]"
+        lhs, rhs = expr.elements
         if eval_assign(self, lhs, rhs, evaluation):
             return SymbolNull
 
@@ -355,14 +353,21 @@ class UpSet(InfixOperator):
     attributes = A_HOLD_FIRST | A_PROTECTED | A_SEQUENCE_HOLD
     grouping = "Right"
 
+    messages = {
+        "normal": "Nonatomic expression expected at position `1` in `2`.",
+        "nosym": "`1` does not contain a symbol to attach a rule to.",
+    }
     summary_text = (
         "set value and associate the assignment with symbols that occur at level one"
     )
 
-    def eval(
-        self, lhs: BaseElement, rhs: BaseElement, evaluation: Evaluation
-    ) -> Optional[BaseElement]:
-        "lhs_ ^= rhs_"
+    def eval(self, expr: BaseElement, evaluation: Evaluation) -> Optional[BaseElement]:
+        "Pattern[expr, _ ^=_]"
+        lhs, rhs = expr.elements
+        if not hasattr(lhs, "elements"):
+            # This should be the argument of this method...
+            evaluation.message(self.get_name(), "normal", Integer1, expr)
+            return None
 
         eval_assign(self, lhs, rhs, evaluation, upset=True)
         return rhs
@@ -395,10 +400,14 @@ class UpSetDelayed(UpSet):
         "with symbols that occur at level one"
     )
 
-    def eval(
-        self, lhs: BaseElement, rhs: BaseElement, evaluation: Evaluation
-    ) -> Symbol:
-        "lhs_ ^:= rhs_"
+    def eval(self, expr: BaseElement, evaluation: Evaluation) -> Symbol:
+        "Pattern[expr, _ ^:=_]"
+        lhs, rhs = expr.elements
+        if not hasattr(lhs, "elements"):
+            # This should be the argument of this method...
+            expression = Expression(Symbol(self.get_name()), lhs, rhs)
+            evaluation.message(self.get_name(), "normal", Integer1, expr)
+            return None
 
         if eval_assign(self, lhs, rhs, evaluation, upset=True):
             return SymbolNull

mathics/builtin/patterns/composite.py

@@ -173,6 +173,11 @@ def match(self, expression: Expression, pattern_context: dict):
         #     yield new_vars_dict, rest
         self.pattern.match(expression, pattern_context)
 
+    def get_sort_key(self, pattern_sort=True):
+        if not pattern_sort:
+            return self.expr.get_sort_key()
+        return self.pattern.get_sort_key(True)
+
 
 class Longest(Builtin):
     """

mathics/core/assignment.py

@@ -202,6 +202,35 @@ def normalize_lhs(lhs, evaluation):
     return lhs, lookup_name
 
 
+def pop_focus_head(lhs: Expression, focus: BaseElement):
+    """
+    Convert expressions of the form
+    ```
+    Head1[Head2[...Headn[FocusHead[a,b],p1],p2,...]..]
+    ```
+    into
+    ```
+    FocusHead[Head1[Head2[...Headn[a],p1],p2,...]..],b]
+    ```
+    Used in eval_assign_[n|format|...]
+    """
+    if lhs is focus:
+        return lhs
+
+    lhs_head = lhs.get_head()
+    if lhs_head is focus:
+        return lhs
+
+    elems = lhs.elements
+    focus_expr = elems[0]
+    if focus_expr.get_head() is not focus:
+        focus_expr = pop_focus_head(focus_expr, focus)
+
+    focus_elems = focus_expr.elements
+    inner = Expression(lhs_head, focus_elems[0], *elems[1:])
+    return Expression(focus, inner, *focus_elems[1:])
+
+
 def repl_pattern_by_symbol(expr: BaseElement) -> BaseElement:
     """
     If `expr` is a named pattern expression `Pattern[symb, pat]`,

mathics/core/builtin.py

@@ -462,12 +462,17 @@ def get_functions(self, prefix="eval", is_pymodule=False):
                 if pattern is None:  # Fixes PyPy bug
                     continue
                 else:
-                    # TODO: consider to use a more sophisticated
+                    # TODO 1: consider to use a more sophisticated
                     # regular expression, which handles breaklines
                     # more properly, that supports format names
                     # with contexts (context`name) and be less
                     # fragile against leaving spaces between the
                     # elements.
+                    #
+                    # TODO 2: allow
+                    # expr: pat
+                    # to allow passing the whole expression instead their elements.
+                    # This requires to change how Format rules are stored...
                     m = re.match(
                         r"[(]([\w,]+),[ ]*[)]\:\s*(.*)", pattern.replace("\n", " ")
                     )

mathics/core/definitions.py

@@ -161,9 +161,6 @@ def __init__(
             "Global`",
         )
         self.inputfile = ""
-
-        # These are used by TraceEvaluation to```
-        # whether what information to show.
         self.trace_evaluation = False
         self.trace_show_rewrite = False
         self.timing_trace_evaluation = False
@@ -872,9 +869,10 @@ def strip_pattern_name_and_condition(pat) -> BaseElement:
             # We have to use get_head_name() below because
             # pat can either SymbolCondition or <AtomPattern: System`Condition>.
             # In the latter case, comparing to SymbolCondition is not sufficient.
-            if pat.get_head_name() == "System`Condition":
-                if len(pat.elements) > 1:
-                    return strip_pattern_name_and_condition(pat.elements[0])
+            if pat.has_form(("System`Condition", "System`PatternTest"), 2):
+                return strip_pattern_name_and_condition(pat.elements[0])
+            if pat.has_form("System`HoldPattern", 1):
+                return strip_pattern_name_and_condition(pat.elements[0])
             # The same kind of get_head_name() check is needed here as well and
             # is not the same as testing against SymbolPattern.
             if pat.get_head_name() == "System`Pattern":
@@ -996,10 +994,26 @@ def insert_rule(values: List[BaseRule], rule: BaseRule) -> None:
 
     """
 
-    for index, existing in enumerate(values):
-        if existing.pattern.sameQ(rule.pattern):
-            del values[index]
-            break
+    def is_conditional(x):
+        """
+        Check if the replacement rule is a conditional replacement.
+        FunctionApplyRules are always considered "conditional", while
+        replacement rules are conditional if the replace attribute is
+        a conditional expression.
+        """
+        return not hasattr(x, "replace") or x.replace.has_form("System`Condition", 2)
+
+    # If the rule is not conditional, and there are
+    # equivalent rules which are not conditional either,
+    # remove them.
+    if not is_conditional(rule):
+        for index, existing in enumerate(values):
+            if is_conditional(existing):
+                continue
+            if existing.pattern.sameQ(rule.pattern):
+                del values[index]
+                break
+
     # use insort_left to guarantee that if equal rules exist, newer rules will
     # get higher precedence by being inserted before them. see DownValues[].
     bisect.insort_left(values, rule)

mathics/core/expression.py

@@ -613,19 +613,35 @@ def evaluate(
 
     def evaluate_elements(self, evaluation) -> "Expression":
         """
-        return a new expression with the same head, and the
-        evaluable elements evaluated.
+        return a new expression with the head and the
+        evaluable elements evaluated, according to the attributes.
         """
+        head = self._head
+        if isinstance(head, EvalMixin):
+            head = head.evaluate(evaluation) or head
+        attributes = head.get_attributes(evaluation.definitions)
+        if (A_HOLD_ALL | A_HOLD_ALL_COMPLETE) & attributes:
+            return Expression(head, *self._elements)
+        if A_HOLD_REST & attributes:
+            first, *rest = self._elements
+            if isinstance(first, EvalMixin):
+                first = first.evaluate(evaluation) or first
+            return Expression(head, first, *rest)
+
         elements = []
-        for element in self._elements:
+        for pos, element in enumerate(self._elements):
+            if pos == 0 and (A_HOLD_FIRST & attributes):
+                elements.append(element)
+                continue
+
             if isinstance(element, EvalMixin):
                 result = element.evaluate(evaluation)
                 if result is not None:
                     element = result
             elements.append(element)
-        head = self._head
-        if isinstance(head, Expression):
-            head = head.evaluate_elements(evaluation)
+
+        # if isinstance(head, Expression):
+        #    head = head.evaluate_elements(evaluation)
         return Expression(head, *elements)
 
     def filter(self, head, cond, evaluation: Evaluation, count: Optional[int] = None):

mathics/core/rules.py

@@ -57,7 +57,7 @@ def eval_f(self, x, evaluation) -> Optional[Expression]:
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.pattern import BasePattern, StopGenerator
-from mathics.core.symbols import strip_context
+from mathics.core.symbols import SymbolTrue, strip_context
 
 
 def _python_function_arguments(f):
@@ -76,6 +76,15 @@ class StopGenerator_BaseRule(StopGenerator):
     pass
 
 
+class RuleApplicationFailed(Exception):
+    """
+    Exception raised when a condition fails
+    in the RHS, indicating that the match have failed.
+    """
+
+    pass
+
+
 class BaseRule(KeyComparable, ABC):
     """This is the base class from which the FunctionApplyRule and
     Rule classes are derived from.
@@ -134,9 +143,10 @@ def yield_match(vars, rest):
                 if isinstance(self, FunctionApplyRule)
                 else self.apply_rule
             )
-            new_expression = apply_fn(expression, vars, options, evaluation)
-            if new_expression is None:
-                new_expression = expression
+            try:
+                new_expression = apply_fn(expression, vars, options, evaluation)
+            except RuleApplicationFailed:
+                return None
             if rest[0] or rest[1]:
                 result = Expression(
                     expression.get_head(),
@@ -254,6 +264,13 @@ def apply_rule(
         new = self.replace.replace_vars(vars)
         new.options = options
 
+        while new.has_form("System`Condition", 2):
+            new, cond = new.get_elements()
+            if isinstance(cond, Expression):
+                cond = cond.evaluate(evaluation)
+            if cond is not SymbolTrue:
+                raise RuleApplicationFailed()
+
         # If options is a non-empty dict, we need to ensure
         # reevaluation of the whole expression, since 'new' will
         # usually contain one or more matching OptionValue[symbol_]
@@ -284,6 +301,16 @@ def get_replace_value(self) -> BaseElement:
     def __repr__(self) -> str:
         return "<Rule: %s -> %s>" % (self.pattern, self.replace)
 
+    def get_sort_key(self, pattern_sort=True) -> tuple:
+        # FIXME: check if this makes sense:
+        if not pattern_sort:
+            return tuple((self.system, self.pattern.get_sort_key(False)))
+
+        sort_key = list(self.pattern.get_sort_key(True))
+        if self.replace.has_form("System`Condition", 2):
+            sort_key[-1] = 0
+        return tuple((self.system, tuple(sort_key)))
+
 
 class FunctionApplyRule(BaseRule):
     """
@@ -358,9 +385,12 @@ def apply_function(
         # context marks.
         vars_noctx = dict(((strip_context(s), vars[s]) for s in vars))
         if options:
-            return self.function(evaluation=evaluation, options=options, **vars_noctx)
+            return (
+                self.function(evaluation=evaluation, options=options, **vars_noctx)
+                or expression
+            )
         else:
-            return self.function(evaluation=evaluation, **vars_noctx)
+            return self.function(evaluation=evaluation, **vars_noctx) or expression
 
     def __repr__(self) -> str:
         # Cython doesn't allow f-string below and reports: