a bunch of fixes

CHANGES.rst

@@ -42,15 +42,17 @@ Internals
 #. ``eval*`` methods in `Builtin` classes are considerer as synonyms of ``apply*`` methods.
 #. Modularize and improve the way in which `Builtin` classes are selected to have an associated `Definition`.
 #. `_SetOperator.assign_elementary` was renamed as `_SetOperator.assign`. All the special cases are not handled by the `_SetOperator.special_cases` dict.
-
-
+#. ``get_sort_key`` now has a uniform interface on all the subclasses of ``KeyComparable``, accepting the parameter `pattern_sort`.
+#. circular dependencies in ``mathics.core.definitions`` were reduced.
+#. `to_boxes` now returns always a `FullForm` of the input Expression, instead of raising an exception.
 
 Bugs
 ++++
 
 # ``0`` with a given precision (like in ```0`3```) is now parsed as ``0``, an integer number.
 #. ``RandomSample`` with one list argument now returns a random ordering of the list items. Previously it would return just one item.
-
+#. Rules of the form ``pat->Condition[expr, cond]`` are handled as in WL. The same works for nested `Condition` expressions. Also, comparisons among these rules was improved.
+
 
 Enhancements
 ++++++++++++

mathics/builtin/assignments/assignment.py

@@ -170,11 +170,21 @@ class SetDelayed(Set):
     'Condition' ('/;') can be used with 'SetDelayed' to make an
     assignment that only holds if a condition is satisfied:
     >> f[x_] := p[x] /; x>0
+    >> f[x_] := p[-x]/; x<-2
     >> f[3]
      = p[3]
     >> f[-3]
-     = f[-3]
-    It also works if the condition is set in the LHS:
+     = p[3]
+    >> f[-1]
+     = f[-1]
+    Notice that the LHS is the same in both definitions, but the second
+    does not overwrite the first one.
+
+    To overwrite one of these definitions, we have to assign using the same condition:
+    >> f[x_] := Sin[x] /; x>0
+    >> f[3]
+     = Sin[3] 
+    In a similar way, the condition can be set in the LHS:
     >> F[x_, y_] /; x < y /; x>0  := x / y;
     >> F[x_, y_] := y / x;
     >> F[2, 3]

mathics/builtin/base.py

@@ -818,15 +818,15 @@ def get_head_name(self):
     def get_lookup_name(self):
         return self.get_name()
 
-    def get_sort_key(self) -> tuple:
+    def get_sort_key(self, pattern_sort=False) -> tuple:
         return self.to_expression().get_sort_key()
 
     def get_string_value(self):
         return "-@" + self.get_head_name() + "@-"
 
     def sameQ(self, expr) -> bool:
         """Mathics SameQ"""
-        return expr.sameQ(self)
+        return self.to_expression().sameQ(expr)
 
     def do_format(self, evaluation, format):
         return self

mathics/builtin/box/layout.py

@@ -23,6 +23,7 @@
 from mathics.core.symbols import Symbol, SymbolMakeBoxes
 from mathics.core.systemsymbols import (
     SymbolFractionBox,
+    SymbolFullForm,
     SymbolRowBox,
     SymbolSqrtBox,
     SymbolStandardForm,
@@ -58,7 +59,7 @@ def to_boxes(x, evaluation: Evaluation, options={}) -> BoxElementMixin:
             return x_boxed
         if isinstance(x_boxed, Atom):
             return to_boxes(x_boxed, evaluation, options)
-    raise Exception(x, "cannot be boxed.")
+    return to_boxes(Expression(SymbolFullForm, x), evaluation, options)
 
 
 class BoxData(Builtin):
@@ -201,7 +202,10 @@ class RowBox(BoxExpression):
     summary_text = "horizontal arrange of boxes"
 
     def __repr__(self):
-        return "RowBox[List[" + self.items.__repr__() + "]]"
+        try:
+            return "RowBox[List[" + self.items.__repr__() + "]]"
+        except:
+            return "RowBox[List[{uninitialized}]]"
 
     def apply_list(self, boxes, evaluation):
         """RowBox[boxes_List]"""

mathics/builtin/patterns.py

@@ -172,7 +172,8 @@ def create_rules(rules_expr, expr, name, evaluation, extra_args=[]):
     else:
         result = []
         for rule in rules:
-            if rule.get_head_name() not in ("System`Rule", "System`RuleDelayed"):
+            head_name = rule.get_head_name()
+            if head_name not in ("System`Rule", "System`RuleDelayed"):
                 evaluation.message(name, "reps", rule)
                 return None, True
             elif len(rule.elements) != 2:
@@ -186,7 +187,13 @@ def create_rules(rules_expr, expr, name, evaluation, extra_args=[]):
                 )
                 return None, True
             else:
-                result.append(Rule(rule.elements[0], rule.elements[1]))
+                result.append(
+                    Rule(
+                        rule.elements[0],
+                        rule.elements[1],
+                        delayed=(head_name == "System`RuleDelayed"),
+                    )
+                )
         return result, False
 
 
@@ -1690,7 +1697,7 @@ def __init__(self, rulelist, evaluation):
         self._elements = None
         self._head = SymbolDispatch
 
-    def get_sort_key(self) -> tuple:
+    def get_sort_key(self, pattern_sort=False) -> tuple:
         return self.src.get_sort_key()
 
     def get_atom_name(self):