WIP - skeletal Form refactor for discussion

Minimal code to show how we might refactor and organize Form boxing
in a way that is simpler, more flexible, and closer to WMA.

Author: rocky

mathics/builtin/box/layout.py

@@ -21,13 +21,15 @@
 from mathics.core.expression import Expression
 from mathics.core.list import ListExpression
 from mathics.core.symbols import Symbol, SymbolMakeBoxes
-from mathics.core.systemsymbols import SymbolRowBox, SymbolStandardForm
-
-SymbolFractionBox = Symbol("System`FractionBox")
-SymbolSubscriptBox = Symbol("System`SubscriptBox")
-SymbolSubsuperscriptBox = Symbol("System`SubsuperscriptBox")
-SymbolSuperscriptBox = Symbol("System`SuperscriptBox")
-SymbolSqrtBox = Symbol("System`SqrtBox")
+from mathics.core.systemsymbols import (
+    SymbolFractionBox,
+    SymbolRowBox,
+    SymbolSqrtBox,
+    SymbolStandardForm,
+    SymbolSubsuperscriptBox,
+    SymbolSubscriptBox,
+    SymbolSuperscriptBox,
+)
 
 
 # this temporarily replaces the _BoxedString class
@@ -165,8 +167,7 @@ class InterpretationBox(BoxExpression):
     """
     <dl>
       <dt>'InterpretationBox[{...}, expr]'
-      <dd> is a low-level box construct that displays as
-    boxes but is interpreted on input as expr.
+      <dd> is a low-level box construct that displays as boxes, but is interpreted on input as expr.
     </dl>
 
     >> A = InterpretationBox["Pepe", 4]

mathics/builtin/forms/__init__.py

@@ -4,7 +4,7 @@
 A <i>Form</i> format specifies the way Mathics Expression input is read or output written.
 
 The variable <url>:$OutputForms':
-http://localhost:8000/doc/reference-of-built-in-symbols/forms-of-input-and-output/$outputforms/</url> has a list of Forms defined.
+http://localhost:8000/doc/reference-of-built-in-symbols/forms-of-input-and-output/form-variables/$outputforms/</url> has a list of Forms defined.
 
 See also <url>:WMA link:
 https://reference.wolfram.com/language/tutorial/TextualInputAndOutput.html#12368</url>.

mathics/builtin/forms/base.py

@@ -1,8 +1,13 @@
+from typing import Callable
+
 import mathics.core.definitions as definitions
 
 from mathics.builtin.base import Builtin
+from mathics.core.element import BaseElement
 from mathics.core.symbols import Symbol
 
+form_symbol_to_class = {}
+
 
 class FormBaseClass(Builtin):
     """
@@ -11,6 +16,9 @@ class FormBaseClass(Builtin):
     All Forms should subclass this.
     """
 
+    # Mapping from Form and element type to a callable boxing method
+    form_box_methods = {}
+
     # Using "__new__" is not optimal for what we want.
     # We basically want to hook into class construction in order to
     # detect certain class attributes so we can add them to a list.
@@ -29,8 +37,60 @@ def __new__(cls, *args, **kwargs):
             if name in definitions.OutputForms:
                 raise RuntimeError(f"{name} already added to $OutputsForms")
             definitions.OutputForms.add(Symbol(name))
+        form_symbol_to_class[Symbol(name)] = cls
         return instance
 
+    @classmethod
+    def box(cls, element: BaseElement, evaluation):
+        """
+        This method is is called for each element that can be boxed.
+        ("box" here is a an active verb, not a noun).
+
+        This is a generic routine which calls the specific boxing routine
+        that has been regstered in class variable ``form_box_methods`` previously.
+
+        If nothing has been registered, we just return ``element`` back unmodified
+        as we do in evaluation.
+
+        Specific and custom method need to be implemented for each Form
+        and element_type that perform some kind of boxing.
+        """
+        method = cls.form_box_methods.get((cls, element.head), None)
+        if method is None:
+            # The default class should have been registered under FormBaseClass
+            method = cls.form_box_methods.get((FormBaseClass, element.head), None)
+            if method is None:
+                # Just return the element unmodified.
+                # Note: this is what we do in evaluation when we don't have a match
+                return element
+
+        return method(element, evaluation)
+
+    @classmethod
+    def register_box_method(cls, symbol: Symbol, method: Callable):
+        """
+        Register ``method`` so method(element, ...) is called when
+        ``form.box(element, ...)`` is called.
+
+        "form" is something like ``StandardForm``, ``TraditionalForm``, etc.
+
+        To register the default boxing routine, register under the class
+        ``FormBaseClass``
+        """
+
+        cls.form_box_methods[cls, symbol] = method
+
+
+def box(element: BaseElement, evaluation, form: Symbol):
+    """
+    Basically redirects the "box" call from a form symbol name to the "box" method off of
+    the Form class named by the symbol.
+    """
+    form_class = form_symbol_to_class.get(form, None)
+    if form_class is None:
+        return element
+    return form_class.box(element, evaluation)
+
 
 # FormBaseClass is a public Builtin class that
 # should not get added as a definition (and therefore not added to

mathics/builtin/forms/default_boxing.py

@@ -0,0 +1,39 @@
+"""
+Registers boxing routines for a number of the standard Builtin forms and Builtin Symbols
+"""
+
+from mathics.builtin.box.layout import (
+    SymbolFractionBox,
+    SymbolSqrtBox,
+    SymbolSuperscriptBox,
+)
+from mathics.builtin.forms.output import StandardForm, TraditionalForm
+from mathics.core.expression import Expression
+from mathics.core.symbols import SymbolDivide
+from mathics.core.systemsymbols import SymbolPower, SymbolSqrt
+
+
+def box_divide(expr: Expression, evaluation):
+    assert (
+        len(expr.elements) == 2
+    ), "Fraction Box element {elements} should have two items"
+    return Expression(SymbolFractionBox, *expr.elements)
+
+
+def box_power(expr: Expression, evaluation):
+    assert (
+        len(expr.elements) == 2
+    ), "Fraction Box element {elements} should have two items"
+    return Expression(SymbolSuperscriptBox, *expr.elements)
+
+
+def box_sqrt(expr: Expression, evaluation):
+    assert len(expr.elements) == 1, "Sqrt Box element {elements} should have one item"
+    return Expression(SymbolSqrtBox, *expr.elements)
+
+
+# More general, should we iterate over $BoxForms?
+for form in (StandardForm, TraditionalForm):
+    form.register_box_method(SymbolDivide, box_divide)
+    form.register_box_method(SymbolPower, box_power)
+    form.register_box_method(SymbolSqrt, box_sqrt)