Mathics3 · mmatera · Nov 10, 2024 · Feb 11, 2025 · Sep 7, 2025 · Dec 23, 2025
diff --git a/mathics/__main__.py b/mathics/__main__.py
@@ -247,7 +247,7 @@ def print_result(self, result, no_out_prompt=False, strict_wl_output=False):
 
         out_str = str(result.result)
         if eval_type == "System`String" and not strict_wl_output:
-            out_str = '"' + out_str.replace('"', r"\"") + '"'
+            out_str = out_str.replace('"', r"\"")
         if eval_type == "System`Graph":
             out_str = "-Graph-"
 

diff --git a/mathics/builtin/datentime.py b/mathics/builtin/datentime.py
@@ -593,7 +593,7 @@ class DateObject(_DateFormat, ImmutableValueMixin):
     </dl>
 
     >> DateObject[{2020, 4, 15}]
-     = [...]
+     = ...
     """
 
     fmt_keywords = {
@@ -697,7 +697,7 @@ def eval_makeboxes(
         fmt: BaseElement,
         evaluation: Evaluation,
     ) -> Optional[Expression]:
-        "MakeBoxes[DateObject[datetime_List, gran_, cal_, tz_, fmt_], StandardForm|TraditionalForm|OutputForm]"
+        "MakeBoxes[DateObject[datetime_List, gran_, cal_, tz_, fmt_], StandardForm|TraditionalForm]"
         # TODO:
         if fmt.sameQ(SymbolAutomatic):
             fmt = ListExpression(String("DateTimeShort"))

diff --git a/mathics/builtin/drawing/graphics3d.py b/mathics/builtin/drawing/graphics3d.py
@@ -140,11 +140,6 @@ class Graphics3D(Graphics):
 
     messages = {"invlight": "`1` is not a valid list of light sources."}
 
-    rules = {
-        "MakeBoxes[Graphics3D[content_, OptionsPattern[Graphics3D]], "
-        "        OutputForm]": '"-Graphics3D-"'
-    }
-
 
 def total_extent_3d(extents):
     xmin = xmax = ymin = ymax = zmin = zmax = None

diff --git a/mathics/builtin/forms/data.py b/mathics/builtin/forms/data.py
@@ -11,23 +11,16 @@
 """
 from typing import Any, Callable, Dict, List, Optional
 
-from mathics.builtin.box.layout import RowBox, StyleBox
+from mathics.builtin.box.layout import RowBox, StyleBox, SuperscriptBox
 from mathics.builtin.forms.base import FormBaseClass
 from mathics.core.atoms import Integer, Real, String
 from mathics.core.builtin import Builtin
 from mathics.core.element import BaseElement
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
-from mathics.core.list import ListExpression
 from mathics.core.number import dps
 from mathics.core.symbols import Atom, Symbol, SymbolFalse, SymbolNull, SymbolTrue
-from mathics.core.systemsymbols import (
-    SymbolAutomatic,
-    SymbolInfinity,
-    SymbolMakeBoxes,
-    SymbolRowBox,
-    SymbolSuperscriptBox,
-)
+from mathics.core.systemsymbols import SymbolAutomatic, SymbolInfinity, SymbolMakeBoxes
 from mathics.eval.strings import eval_StringForm_MakeBoxes, eval_ToString
 from mathics.format.box import (
     StringLParen,
@@ -95,7 +88,7 @@ class BaseForm(FormBaseClass):
 
     def eval_makeboxes(self, expr, n, f, evaluation: Evaluation):
         """MakeBoxes[BaseForm[expr_, n_],
-        f:StandardForm|TraditionalForm|OutputForm]"""
+        (f:StandardForm|TraditionalForm)]"""
         try:
             return eval_baseform(expr, n, f, evaluation)
         except ValueError:
@@ -564,16 +557,13 @@ def default_NumberFormat(
         py_exp = exp.get_string_value()
         if py_exp:
             mul = String(options["NumberMultiplier"])
-            return Expression(
-                SymbolRowBox,
-                ListExpression(man, mul, Expression(SymbolSuperscriptBox, base, exp)),
-            )
+            return RowBox(man, mul, SuperscriptBox(base, exp))
 
         return man
 
     def eval_makeboxes(self, fexpr, form, evaluation):
         """MakeBoxes[fexpr:NumberForm[_?AtomQ, ___],
-        form:StandardForm|TraditionalForm|OutputForm]"""
+        form:StandardForm|TraditionalForm]"""
         try:
             target, prec_parms, py_options = get_numberform_parameters(
                 fexpr, evaluation
@@ -603,7 +593,6 @@ def eval_makeboxes(self, fexpr, form, evaluation):
 
         if py_n is not None:
             py_options["_Form"] = form.get_name()
-
             return numberform_to_boxes(target, py_n, py_f, evaluation, py_options)
         return Expression(SymbolMakeBoxes, target, form)
 
@@ -637,7 +626,7 @@ class SequenceForm(FormBaseClass):
 
     def eval_makeboxes(self, args, form, evaluation, options: dict):
         """MakeBoxes[SequenceForm[args___, OptionsPattern[SequenceForm]],
-        form:StandardForm|TraditionalForm|OutputForm]"""
+        form:StandardForm|TraditionalForm]"""
         encoding = options["System`CharacterEncoding"]
         return RowBox(
             *[
@@ -712,7 +701,7 @@ class StringForm(FormBaseClass):
 
     def eval_makeboxes(self, s, args, form, evaluation):
         """MakeBoxes[StringForm[s_String, args___],
-        form:StandardForm|TraditionalForm|OutputForm]"""
+        form:StandardForm|TraditionalForm]"""
         try:
             result = eval_StringForm_MakeBoxes(s, args.get_sequence(), form, evaluation)
         except ValueError:
@@ -771,8 +760,8 @@ class TableForm(FormBaseClass):
     summary_text = "format as a table"
 
     def eval_makeboxes(self, table, f, evaluation, options):
-        """MakeBoxes[%(name)s[table_, OptionsPattern[%(name)s]],
-        f:StandardForm|TraditionalForm|OutputForm]"""
+        """MakeBoxes[%(name)s[table_, OptionsPattern[]],
+        f:StandardForm|TraditionalForm]"""
         return eval_tableform(self, table, f, evaluation, options)
 
 
@@ -803,9 +792,8 @@ class MatrixForm(TableForm):
     summary_text = "format as a matrix"
 
     def eval_makeboxes_matrix(self, table, form, evaluation, options):
-        """MakeBoxes[%(name)s[table_, OptionsPattern[%(name)s]],
-        form:StandardForm|TraditionalForm]"""
-
+        """MakeBoxes[MatrixForm[table_, OptionsPattern[]],
+        (form:StandardForm|TraditionalForm)]"""
         result = super().eval_makeboxes(table, form, evaluation, options)
         if result.get_head_name() == "System`GridBox":
             return RowBox(StringLParen, result, StringRParen)

diff --git a/mathics/builtin/forms/print.py b/mathics/builtin/forms/print.py
@@ -17,8 +17,13 @@
 from mathics.core.atoms import String
 from mathics.core.expression import Expression
 from mathics.core.symbols import SymbolFalse, SymbolFullForm, SymbolTrue
-from mathics.core.systemsymbols import SymbolInputForm
-from mathics.format.box import eval_makeboxes_fullform, eval_mathmlform, eval_texform
+from mathics.core.systemsymbols import SymbolInputForm, SymbolOutputForm
+from mathics.format.box import (
+    eval_makeboxes_fullform,
+    eval_makeboxes_outputform,
+    eval_mathmlform,
+    eval_texform,
+)
 from mathics.format.form import render_input_form
 
 sort_order = "mathics.builtin.forms.general-purpose-forms"
@@ -113,7 +118,7 @@ class InputForm(FormBaseClass):
 
     # TODO: eventually, remove OutputForm in the second argument.
     def eval_makeboxes(self, expr, evaluation):
-        """MakeBoxes[InputForm[expr_], Alternatives[StandardForm,TraditionalForm,OutputForm]]"""
+        """MakeBoxes[InputForm[expr_], Alternatives[StandardForm,TraditionalForm]]"""
 
         inputform = String(render_input_form(expr, evaluation))
         inputform = StyleBox(
@@ -165,7 +170,7 @@ class MathMLForm(FormBaseClass):
     summary_text = "format expression as MathML commands"
 
     def eval_mathml(self, expr, evaluation) -> Expression:
-        "MakeBoxes[MathMLForm[expr_], (OutputForm|StandardForm|TraditionalForm)]"
+        "MakeBoxes[MathMLForm[expr_], Alternatives[StandardForm,TraditionalForm]]"
         return eval_mathmlform(expr, evaluation)
 
 
@@ -194,9 +199,15 @@ class OutputForm(FormBaseClass):
      = -Graphics-
     """
 
+    formats = {"OutputForm[s_String]": "s"}
     summary_text = "format expression in plain text"
-    # Remove me at the end of the refactor
-    rules = {"MakeBoxes[OutputForm[expr_], form_]": "MakeBoxes[expr, OutputForm]"}
+
+    def eval_makeboxes(self, expr, form, evaluation):
+        """MakeBoxes[OutputForm[expr_], form_]"""
+        pane = eval_makeboxes_outputform(expr, evaluation, form)
+        return InterpretationBox(
+            pane, Expression(SymbolOutputForm, expr), **{"System`Editable": SymbolFalse}
+        )
 
 
 class StandardForm(FormBaseClass):
@@ -266,5 +277,7 @@ class TeXForm(FormBaseClass):
     summary_text = "format expression as LaTeX commands"
 
     def eval_tex(self, expr, evaluation) -> Expression:
-        "MakeBoxes[TeXForm[expr_], (OutputForm|StandardForm|TraditionalForm)]"
+        "MakeBoxes[TeXForm[expr_], Alternatives[StandardForm,TraditionalForm]]"
+        # TeXForm by default uses `TraditionalForm`
+
         return eval_texform(expr, evaluation)
diff --git a/mathics/builtin/functional/application.py b/mathics/builtin/functional/application.py
@@ -198,9 +198,7 @@ class Slot(SympyFunction, PrefixOperator):
     rules = {
         "Slot[]": "Slot[1]",
         "MakeBoxes[Slot[n_Integer?NonNegative],"
-        "  f:StandardForm|TraditionalForm|InputForm|OutputForm]": (
-            '"#" <> ToString[n]'
-        ),
+        "  (f:StandardForm|TraditionalForm)]": ('"#" <> ToString[n]'),
     }
     summary_text = "one argument of a pure function"
 
@@ -237,6 +235,6 @@ class SlotSequence(PrefixOperator, Builtin):
     rules = {
         "SlotSequence[]": "SlotSequence[1]",
         "MakeBoxes[SlotSequence[n_Integer?Positive],"
-        "f:StandardForm|TraditionalForm|InputForm|OutputForm]": ('"##" <> ToString[n]'),
+        "(f:StandardForm|TraditionalForm)]": ('"##" <> ToString[n]'),
     }
     summary_text = "the full sequence of arguments of a pure function"
diff --git a/mathics/builtin/graphics.py b/mathics/builtin/graphics.py
@@ -316,7 +316,7 @@ class Graphics(Builtin):
 
     def eval_makeboxes(self, content, evaluation, options):
         """MakeBoxes[%(name)s[content_, OptionsPattern[%(name)s]],
-        StandardForm|TraditionalForm|OutputForm]"""
+        Alternatives[StandardForm,TraditionalForm]]"""
 
         def convert(content):
             head = content.get_head()

diff --git a/mathics/builtin/kernel_sessions.py b/mathics/builtin/kernel_sessions.py
@@ -55,9 +55,9 @@ class Out(Builtin):
         "Out[k_Integer?Negative]": "Out[$Line + k]",
         "Out[]": "Out[$Line - 1]",
         "MakeBoxes[Out[k_Integer?((-10 <= # < 0)&)],"
-        "    f:StandardForm|TraditionalForm|InputForm|OutputForm]": r'StringJoin[ConstantArray["%%", -k]]',
+        "    f:StandardForm|TraditionalForm]": r'StringJoin[ConstantArray["%%", -k]]',
         "MakeBoxes[Out[k_Integer?Positive],"
-        "    f:StandardForm|TraditionalForm|InputForm|OutputForm]": r'"%%" <> ToString[k]',
+        "    f:StandardForm|TraditionalForm]": r'"%%" <> ToString[k]',
     }
     summary_text = "result of the Kth input line"
 

diff --git a/mathics/builtin/layout.py b/mathics/builtin/layout.py
@@ -121,7 +121,7 @@ class Grid(Builtin):
 
     def eval_makeboxes(self, array, f, evaluation: Evaluation, options) -> Expression:
         """MakeBoxes[Grid[array_List, OptionsPattern[Grid]],
-        f:StandardForm|TraditionalForm|OutputForm]"""
+        f:StandardForm|TraditionalForm]"""
 
         elements = array.elements
 
@@ -221,7 +221,7 @@ class Pane(Builtin):
     A Pane is treated as an unbroken rectangular region for purposes of line breaking.
 
     >> Pane[37!]
-     = 13763753091226345046315979581580902400000000
+     = Pane[13763753091226345046315979581580902400000000]
 
     In TeXForm, $Pane$ produce minipage environments:
     >> {{Pane[a,3], Pane[expt, 3]}}//TableForm//TeXForm
@@ -398,7 +398,7 @@ class Row(Builtin):
 
     def eval_makeboxes(self, items, sep, form, evaluation: Evaluation):
         """MakeBoxes[Row[{items___}, sep_:""],
-        form:StandardForm|TraditionalForm|OutputForm]"""
+        form:StandardForm|TraditionalForm]"""
 
         items = items.get_sequence()
         if not isinstance(sep, String):

diff --git a/mathics/builtin/list/associations.py b/mathics/builtin/list/associations.py
@@ -56,7 +56,7 @@ class Association(Builtin):
 
     def eval_makeboxes(self, rules, f, evaluation: Evaluation):
         """MakeBoxes[<|rules___|>,
-        f:StandardForm|TraditionalForm|OutputForm|InputForm]"""
+        (f:StandardForm|TraditionalForm)]"""
 
         def validate(exprs):
             for expr in exprs:

diff --git a/mathics/builtin/list/constructing.py b/mathics/builtin/list/constructing.py
@@ -167,7 +167,7 @@ def eval(self, elements, evaluation: Evaluation):
 
     def eval_makeboxes(self, items, f, evaluation):
         """MakeBoxes[{items___},
-        f:StandardForm|TraditionalForm|OutputForm|InputForm|FullForm]"""
+        (f:StandardForm|TraditionalForm)]"""
 
         items = items.get_sequence()
         return RowBox(*list_boxes(items, f, evaluation, "{", "}"))

diff --git a/mathics/builtin/list/eol.py b/mathics/builtin/list/eol.py
@@ -1168,14 +1168,11 @@ class Part(Builtin):
 
     def eval_makeboxes(self, list, i, f, evaluation):
         """MakeBoxes[Part[list_, i___],
-        f:StandardForm|TraditionalForm|OutputForm|InputForm]"""
+        (f:StandardForm|TraditionalForm)]"""
 
         i = i.get_sequence()
         list = Expression(SymbolMakeBoxes, list, f).evaluate(evaluation)
-        if f.get_name() in ("System`OutputForm", "System`InputForm"):
-            open, close = "[[", "]]"
-        else:
-            open, close = "\u301a", "\u301b"
+        open, close = "\u301a", "\u301b"
         indices = list_boxes(i, f, evaluation, open, close)
         result = RowBox(list, *indices)
         return result

diff --git a/mathics/builtin/mainloop.py b/mathics/builtin/mainloop.py
@@ -93,6 +93,7 @@ class In(Builtin):
      . In[2] = x = x + 1
      .
      . In[1] = x = 1
+     .
     """
 
     attributes = A_LISTABLE | A_PROTECTED

diff --git a/mathics/builtin/makeboxes.py b/mathics/builtin/makeboxes.py
@@ -92,18 +92,17 @@ class MakeBoxes(Builtin):
 
     rules = {
         "MakeBoxes[Infix[head_[elements___]], "
-        "    f:StandardForm|TraditionalForm|OutputForm]": (
+        "    f:StandardForm|TraditionalForm]": (
             'MakeBoxes[Infix[head[elements], StringForm["~`1`~", head]], f]'
         ),
         "MakeBoxes[expr_]": "MakeBoxes[expr, StandardForm]",
         # The following rule is temporal.
         "MakeBoxes[expr_, form:(TeXForm|MathMLForm)]": "MakeBoxes[form[expr], StandardForm]",
         (
             "MakeBoxes[(form:StandardForm|TraditionalForm)"
-            "[expr_], StandardForm|TraditionalForm|OutputForm]"
+            "[expr_], StandardForm|TraditionalForm]"
         ): ("MakeBoxes[expr, form]"),
         # BoxForms goes as second argument
-        "MakeBoxes[(form:StandardForm|TraditionalForm|OutputForm)[expr_], OutputForm]": "MakeBoxes[expr, form]",
         "MakeBoxes[PrecedenceForm[expr_, prec_], f_]": "MakeBoxes[expr, f]",
         "MakeBoxes[Style[expr_, OptionsPattern[Style]], f_]": (
             "StyleBox[MakeBoxes[expr, f], "
@@ -118,26 +117,26 @@ def eval_fullform(self, expr, evaluation):
 
     def eval_general(self, expr, f, evaluation):
         """MakeBoxes[expr_,
-        f:TraditionalForm|StandardForm|OutputForm]"""
+        f:TraditionalForm|StandardForm]"""
         return eval_generic_makeboxes(expr, f, evaluation)
 
     def eval_outerprecedenceform(self, expr, precedence, form, evaluation):
         """MakeBoxes[PrecedenceForm[expr_, precedence_],
-        form:StandardForm|TraditionalForm|OutputForm]"""
+        form:StandardForm|TraditionalForm]"""
 
         py_precedence = precedence.get_int_value()
         boxes = MakeBoxes(expr, form)
         return parenthesize(py_precedence, expr, boxes, True)
 
     def eval_postprefix(self, p, expr, h, precedence, form, evaluation):
         """MakeBoxes[(p:Prefix|Postfix)[expr_, h_, precedence_:None],
-        form:StandardForm|TraditionalForm|OutputForm]"""
+        form:StandardForm|TraditionalForm]"""
         return eval_postprefix(self, p, expr, h, precedence, form, evaluation)
 
     def eval_infix(
         self, expr, operator, precedence: Integer, grouping, form: Symbol, evaluation
     ):
-        """MakeBoxes[Infix[expr_, operator_, precedence_:None, grouping_:None], form:StandardForm|TraditionalForm|OutputForm]"""
+        """MakeBoxes[Infix[expr_, operator_, precedence_:None, grouping_:None], form:StandardForm|TraditionalForm]"""
         return eval_infix(self, expr, operator, precedence, grouping, form, evaluation)
 
 

diff --git a/mathics/builtin/messages.py b/mathics/builtin/messages.py
@@ -335,12 +335,9 @@ class MessageName(InfixOperator):
     messages = {"messg": "Message cannot be set to `1`. It must be set to a string."}
     rules = {
         "MakeBoxes[MessageName[symbol_Symbol, tag_String], "
-        "f:StandardForm|TraditionalForm|OutputForm]": (
+        "f:StandardForm|TraditionalForm]": (
             'RowBox[{MakeBoxes[symbol, f], "::", MakeBoxes[tag, f]}]'
         ),
-        "MakeBoxes[MessageName[symbol_Symbol, tag_String], InputForm]": (
-            'RowBox[{MakeBoxes[symbol, InputForm], "::", tag}]'
-        ),
     }
     summary_text = "associate a message name with a tag"
 

diff --git a/mathics/builtin/numbers/calculus.py b/mathics/builtin/numbers/calculus.py
@@ -417,7 +417,6 @@ class Derivative(PostfixOperator, SympyFunction):
             r'  "\[Prime]\[Prime]", If[{n} === {1}, "\[Prime]", '
             r'    RowBox[{"(", Sequence @@ Riffle[{n}, ","], ")"}]]]]'
         ),
-        "MakeBoxes[Derivative[n:1|2][f_], form:OutputForm]": """RowBox[{MakeBoxes[f, form], If[n==1, "'", "''"]}]""",
         # The following rules should be applied in the eval method, instead of relying on the pattern matching
         # mechanism.
         "Derivative[0...][f_]": "f",
-Original file line number
+Diff line change
@@ Expand Up / @@ -93,6 +93,7 @@ class In(Builtin): @@
          . In[2] = x = x + 1
          .
          . In[1] = x = 1
+         .
         """
         attributes = A_LISTABLE | A_PROTECTED
@@ Expand Down @@