partial

Author: mmatera

mathics/builtin/forms/output.py

@@ -571,13 +571,14 @@ class OutputForm(FormBaseClass):
     formats = {"OutputForm[s_String]": "s"}
     summary_text = "plain-text output format"
 
-    # def apply_makeboxes(self, expr, form, evaluation):
-    #    """MakeBoxes[OutputForm[expr_], form_]"""
-    #    text2d = expression_to_2d_text(expr, evaluation, form).text
-    #    elem1 = PaneBox(String(text2d))
-    #    elem2 = Expression(SymbolOutputForm, expr)
-    #    result = InterpretationBox(elem1, elem2)
-    #    return result
+    def eval_makeboxes(self, expr, form, evaluation):
+        """MakeBoxes[OutputForm[expr_], form_]"""
+        print(" eval Makeboxes outputform")
+        text2d = expression_to_2d_text(expr, evaluation, form).text
+        elem1 = PaneBox(String(text2d))
+        elem2 = Expression(SymbolOutputForm, expr)
+        result = InterpretationBox(elem1, elem2)
+        return result
 
 
 class PythonForm(FormBaseClass):

mathics/builtin/list/associations.py

@@ -10,83 +10,15 @@
 
 
 from mathics.builtin.box.layout import RowBox
-from mathics.builtin.layout import Row
-from mathics.core.atoms import Integer, String
+from mathics.core.atoms import Integer
 from mathics.core.attributes import A_HOLD_ALL_COMPLETE, A_PROTECTED
 from mathics.core.builtin import Builtin, Test
 from mathics.core.convert.expression import to_mathics_list
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.symbols import Symbol, SymbolTrue
-from mathics.core.systemsymbols import (
-    SymbolAssociation,
-    SymbolHoldForm,
-    SymbolInputForm,
-    SymbolMakeBoxes,
-    SymbolMathMLForm,
-    SymbolMissing,
-    SymbolOutputForm,
-    SymbolStandardForm,
-    SymbolTeXForm,
-    SymbolTraditionalForm,
-)
-from mathics.eval.lists import list_boxes, riffle
-from mathics.eval.makeboxes import do_format
-from mathics.eval.strings import eval_ToString
-
-
-class NotAnAssociationItem(Exception):
-    pass
-
-
-SymbolInterpretation = Symbol("System`Interpretation")
-
-ASSOCIATION_DELIMITER_FORMATS = {
-    SymbolInputForm: {"start": String("<|"), "sep": String(", "), "end": String("|>")},
-    SymbolOutputForm: {"start": String("<|"), "sep": String(","), "end": String("|>")},
-    SymbolStandardForm: {
-        "start": String("<|"),
-        "sep": String(","),
-        "end": String("|>"),
-    },
-    SymbolTraditionalForm: {
-        "start": String("<|"),
-        "sep": String(","),
-        "end": String("|>"),
-    },
-    SymbolTeXForm: {"start": String("<|"), "sep": String(", "), "end": String("|>")},
-    SymbolMathMLForm: {"start": String("<|"), "sep": String(","), "end": String("|>")},
-}
-
-
-def format_association(rules: tuple, evaluation: Evaluation, form: Symbol):
-    """Association[rules___]"""
-    delimiters = ASSOCIATION_DELIMITER_FORMATS[form]
-
-    def yield_rules(rule_tuple):
-        for rule in rule_tuple:
-            if rule.has_form(("Rule", "RuleDelayed"), 2):
-                yield rule
-            elif rule.has_form(
-                (
-                    "List",
-                    "Association",
-                ),
-                None,
-            ):
-                for subrule in yield_rules(rule.elements):
-                    yield subrule
-            else:
-                raise NotAnAssociationItem
-
-    try:
-        items = riffle(
-            [do_format(rule, evaluation, form) for rule in yield_rules(rules)],
-            delimiters["sep"],
-        )
-        return Row(to_mathics_list(delimiters["start"], *items, delimiters["end"]))
-    except NotAnAssociationItem:
-        return None
+from mathics.core.systemsymbols import SymbolAssociation, SymbolMakeBoxes, SymbolMissing
+from mathics.eval.lists import list_boxes
 
 
 class Association(Builtin):
@@ -122,52 +54,34 @@ class Association(Builtin):
 
     summary_text = "an association between keys and values"
 
-    def format_association_input(self, rules, evaluation: Evaluation, expression):
-        """InputForm: Association[rules___]"""
-        print("format association input", rules)
-        formatted = format_association(
-            rules.get_sequence(), evaluation, SymbolInputForm
-        )
-        if formatted is None:
-            return None
-        print("   formatted elements:")
-        elements = formatted.elements[0].elements
-        for elem in elements:
-            print("   ", elem)
-        elems = tuple(
-            (
-                eval_ToString(elem, SymbolOutputForm, "unicode", evaluation).value
-                for elem in elements
+    def eval_makeboxes(self, rules, f, evaluation: Evaluation):
+        """MakeBoxes[<|rules___|>,
+        f:StandardForm|TraditionalForm|OutputForm|InputForm]"""
+
+        def validate(exprs):
+            for expr in exprs:
+                if expr.has_form(("Rule", "RuleDelayed"), 2):
+                    pass
+                elif expr.has_form(("List", "Association"), None):
+                    if not validate(expr.elements):
+                        return False
+                else:
+                    return False
+            return True
+
+        rules = rules.get_sequence()
+        if self.error_idx == 0 and validate(rules) is True:
+            expr = RowBox(*list_boxes(rules, f, evaluation, "<|", "|>"))
+        else:
+            self.error_idx += 1
+            symbol = Expression(SymbolMakeBoxes, SymbolAssociation, f)
+            expr = RowBox(
+                symbol.evaluate(evaluation), *list_boxes(rules, f, evaluation, "[", "]")
             )
-        )
-        elems = tuple((elem[1:-1] if elem[0] == '"' else elem for elem in elems))
-        print("   elems", elems)
-        result_str = "".join(elems)
-        result = Expression(SymbolOutputForm, String(result_str))
-        print("      result->", result)
-        return result
-
-    def format_association_output(self, rules, evaluation: Evaluation):
-        """OutputForm: Association[rules___]"""
-        return format_association(rules.get_sequence(), evaluation, SymbolOutputForm)
-
-    def format_association_standard(self, rules, evaluation: Evaluation):
-        """StandardForm: Association[rules___]"""
-        return format_association(rules.get_sequence(), evaluation, SymbolStandardForm)
-
-    def format_association_traditional(self, rules, evaluation: Evaluation):
-        """TraditionalForm: Association[rules___]"""
-        return format_association(
-            rules.get_sequence(), evaluation, SymbolTraditionalForm
-        )
-
-    def format_association_tex(self, rules, evaluation: Evaluation):
-        """TeXForm: Association[rules___]"""
-        return format_association(rules.get_sequence(), evaluation, SymbolTeXForm)
-
-    def format_association_mathml(self, rules, evaluation: Evaluation):
-        """MathMLForm: Association[rules___]"""
-        return format_association(rules.get_sequence(), evaluation, SymbolMathMLForm)
+
+        if self.error_idx > 0:
+            self.error_idx -= 1
+        return expr
 
     def eval(self, rules, evaluation: Evaluation):
         "Association[rules__]"

mathics/builtin/patterns/rules.py

@@ -503,11 +503,11 @@ class Rule_(BinaryOperator):
      = a
     """
 
-    name = "Rule"
-    operator = "->"
     attributes = A_SEQUENCE_HOLD | A_PROTECTED
     grouping = "Right"
+    name = "Rule"
     needs_verbatim = True
+    operator = "->"
     summary_text = "a replacement rule"
 
     def eval_rule(self, elems, evaluation):

mathics/core/builtin.py

@@ -1151,28 +1151,29 @@ def __init__(self, *args, **kwargs):
 
         # Prevent pattern matching symbols from gaining meaning here using
         # Verbatim
-        name = f"Verbatim[{name}]"
+        verbatim_name = f"Verbatim[{name}]"
 
         # For compatibility, allow grouping symbols in builtins to be
         # specified without System`.
         self.grouping = ensure_context(self.grouping)
 
         if self.grouping in ("System`None", "System`NonAssociative"):
-            op_pattern = f"{name}[items__]"
+            op_pattern = f"{verbatim_name}[items__]"
             replace_items = "items"
         else:
-            op_pattern = f"{name}[x_, y_]"
+            op_pattern = f"{verbatim_name}[x_, y_]"
             replace_items = "x, y"
 
         operator = ascii_operator_to_symbol.get(self.operator, self.__class__.__name__)
 
         if self.default_formats:
-            formats = {
-                op_pattern: "HoldForm[Infix[{%s}, %s, %d, %s]]"
-                % (replace_items, operator, self.precedence, self.grouping)
-            }
-            formats.update(self.formats)
-            self.formats = formats
+            if name not in ("Rule", "RuleDelayed"):
+                formats = {
+                    op_pattern: "HoldForm[Infix[{%s}, %s, %d, %s]]"
+                    % (replace_items, operator, self.precedence, self.grouping)
+                }
+                formats.update(self.formats)
+                self.formats = formats
             formatted = "MakeBoxes[Infix[{%s}, %s, %d,%s], form]" % (
                 replace_items,
                 operator,

mathics/core/convert/prettyprint.py

@@ -181,7 +181,8 @@ def integrate_expression_to_2d_text(expr, evaluation, form, **kwargs):
     if len(elems) > 2 or not kwargs.get("2d", False):
         raise _WrongFormattedExpression
 
-    result = expression_to_2d_text(elems.pop(0), evaluation, form, **kwargs)
+    integrand = elems.pop(0)
+    result = expression_to_2d_text(integrand, evaluation, form, **kwargs)
     while elems:
         var = elems.pop(0)
         if var.has_form("List", 3):

mathics/eval/makeboxes.py

@@ -206,12 +206,26 @@ def eval_makeboxes(
     return Expression(SymbolMakeBoxes, expr, form).evaluate(evaluation)
 
 
+def make_output_form(expr, evaluation, form):
+    """ """
+    from mathics.builtin.box.layout import InterpretationBox, PaneBox
+    from mathics.core.convert.prettyprint import expression_to_2d_text
+
+    text2d = expression_to_2d_text(expr, evaluation, form, **{"2d": True}).text
+    elem1 = PaneBox(String(8 * " " + text2d))
+    elem2 = Expression(SymbolOutputForm, expr)
+    return InterpretationBox(elem1, elem2)
+
+
 def format_element(
     element: BaseElement, evaluation: Evaluation, form: Symbol, **kwargs
 ) -> Optional[BaseElement]:
     """
     Applies formats associated to the expression, and then calls Makeboxes
     """
+    if element.has_form("OutputForm", 1):
+        return make_output_form(element.elements[0], evaluation, form)
+
     expr = do_format(element, evaluation, form)
     if expr is None:
         return None

test/format/test_format.py

@@ -774,13 +774,6 @@
     },
 }
 
-# TODO: REMOVE ME ONCE THE ISSUE WITH FORMATTING ASSOCIATIONS GET SOLVED.
-omit = tuple(
-    (key for key, val in all_test.items() if "Association" in val.get("msg", ""))
-)
-for key in omit:
-    del all_test[key]
-
 
 def load_tests(key):
     """