An example of defining MakeBoxes in Mathics code

We hack assigment for MakeBoxes, but ultimately this is wrong.

There seems to be confusion in MakeBoxes internals with respect
to Rules and delayed assignment.

Author: rocky

mathics/autoload/forms/StandardForm.m

@@ -0,0 +1,21 @@
+(* This implements StandardForm boxing rules in Mathics *)
+
+
+Begin["System`"]
+
+(******************************************************************************************)
+(* Common Boxing routines that are used by many forms. FIXME: place this in another file. *)
+(******************************************************************************************)
+
+(* Change RadBox to RadicalBox. We use RadBox to make it clear that
+   the below code was a read-in from a file and not some pre-existing
+   code. *)
+RadicalBox[expr_, form_] = RadBox[MakeBoxes[expr, form], 3];
+
+(******************************************************************************************)
+(* StandardForm Boxing Rules                                                               *)
+(******************************************************************************************)
+
+MakeBoxes[CubeRoot[expr_], StandardForm] := RadicalBox[expr_, form_];
+(*All the other StandardForm boxing routines... *)
+End[]

mathics/builtin/arithfns/basic.py

@@ -112,9 +112,6 @@ class CubeRoot(Builtin):
     rules = {
         "CubeRoot[n_?NumberQ]": "If[n > 0, Power[n, Divide[1, 3]], Times[-1, Power[Times[-1, n], Divide[1, 3]]]]",
         "CubeRoot[n_]": "Power[n, Divide[1, 3]]",
-        "MakeBoxes[CubeRoot[x_], f:StandardForm|TraditionalForm]": (
-            "RadicalBox[MakeBoxes[x, f], 3]"
-        ),
     }
 
     summary_text = "cubed root"

mathics/builtin/assignments/internals.py

@@ -755,5 +755,21 @@ def assign(self, lhs, rhs, evaluation):
                 return False
             indices = lhs.elements[1:]
             return walk_parts([rule.replace], indices, evaluation, rhs)
+
+        # FIXME: the below is a big hack.
+        # Currently MakeBoxes boxing is implemented as a bunch of rules.
+        # See mathics.builtin.base contribute().
+        # I think we want to change this so it works like normal SetDelayed
+        # That is:
+        #   MakeBoxes[CubeRoot, StandardForm] := RadicalBox[3, StandardForm]
+        # rather than:
+        #   MakeBoxes[CubeRoot, StandardForm] -> RadicalBox[3, StandardForm]
+        elif lhs.get_head_name() == "System`MakeBoxes":
+            makeboxes_rule = Rule(lhs, rhs, system=True)
+            makeboxes_defs = defs.builtin["System`MakeBoxes"]
+            makeboxes_defs.add_rule(makeboxes_rule)
+            # FIXME: what should be the result?
+            return makeboxes_rule
+
         else:
             return self.assign_elementary(lhs, rhs, evaluation)

mathics/builtin/base.py

@@ -284,14 +284,18 @@ def check_options(options_to_check, evaluation):
                 BuiltinRule(name, pattern, function, check_options, system=True)
             )
         for pattern, replace in self.rules.items():
+            # FIXME: sometimes pattern is a string and sometimes a BaseElement?
+            # This seems wrong.
             if not isinstance(pattern, BaseElement):
+                assert pattern
                 pattern = pattern % {"name": name}
                 pattern = parse_builtin_rule(pattern, definition_class)
             replace = replace % {"name": name}
             # FIXME: Should system=True be system=not is_pymodule ?
             rules.append(Rule(pattern, parse_builtin_rule(replace), system=True))
 
         box_rules = []
+        # FIXME: Why a special case for System`MakeBoxes? Remove this
         if name != "System`MakeBoxes":
             new_rules = []
             for rule in rules: