72 more conversions to go

mathics/builtin/inference.py

@@ -13,7 +13,7 @@
 
 from mathics.core.parser import parse_builtin_rule
 from mathics.core.symbols import Symbol
-from mathics.core.systemsymbols import SymbolAnd, SymbolNot, SymbolOr
+from mathics.core.systemsymbols import SymbolAnd, SymbolEqual, SymbolNot, SymbolOr
 
 # TODO: Extend these rules?
 
@@ -331,7 +331,7 @@ def get_assumption_rules_dispatch(evaluation):
                         SymbolFalse,
                     )
                 )
-                for head in ("Equal", "Equivalent"):
+                for head in (SymbolEqual, Symbol("Equivalent")):
                     assumption_rules.append(
                         Rule(
                             Expression(head, pat.elements[0], pat.elements[1]),

mathics/builtin/list/associations.py

@@ -12,20 +12,18 @@
     Test,
 )
 from mathics.builtin.box.inout import RowBox
-
 from mathics.builtin.lists import list_boxes
-
-from mathics.core.expression import Expression
 from mathics.core.atoms import Integer
-from mathics.core.list import ListExpression, to_mathics_list
+from mathics.core.attributes import hold_all_complete, protected
+from mathics.core.expression import Expression
+from mathics.core.list import to_mathics_list
 from mathics.core.symbols import Symbol, SymbolTrue
 from mathics.core.systemsymbols import (
     SymbolAssociation,
     SymbolMakeBoxes,
+    SymbolMissing,
 )
 
-from mathics.core.attributes import hold_all_complete, protected
-
 
 class Association(Builtin):
     """
@@ -157,7 +155,7 @@ def find_key(exprs, rules_dictionary: dict = {}):
             return (
                 result[key]
                 if result
-                else Expression("Missing", Symbol("KeyAbsent"), key)
+                else Expression(SymbolMissing, Symbol("KeyAbsent"), key)
             )
         except TypeError:
             return None
@@ -273,7 +271,7 @@ def get_keys(expr):
                 expr.has_form("Association", None)
                 and AssociationQ(expr).evaluate(evaluation) is SymbolTrue
             ):
-                return ListExpression(*[get_keys(element) for element in expr.elements])
+                return to_mathics_list(*expr.elements, elements_conversion_fn=get_keys)
             else:
                 evaluation.message("Keys", "invrl", expr)
                 raise TypeError

mathics/builtin/list/constructing.py

@@ -10,26 +10,23 @@
 
 
 from mathics.builtin.base import Builtin, Pattern
-
-from mathics.core.element import ElementsProperties
-
 from mathics.builtin.lists import (
     _IterationFunction,
     get_tuples,
 )
-
+from mathics.core.atoms import Integer, Symbol
+from mathics.core.attributes import hold_first, listable, protected
 from mathics.core.convert import from_sympy
-
+from mathics.core.element import ElementsProperties
 from mathics.core.expression import (
     Expression,
     to_expression,
     structure,
 )
-from mathics.core.atoms import Integer
 from mathics.core.list import ListExpression
 from mathics.core.symbols import Atom
 
-from mathics.core.attributes import hold_first, listable, protected
+SymbolNormal = Symbol("Normal")
 
 
 class Array(Builtin):
@@ -155,7 +152,7 @@ def apply_general(self, expr, evaluation):
             return
         return Expression(
             expr.get_head(),
-            *[Expression("Normal", element) for element in expr.elements],
+            *[Expression(SymbolNormal, element) for element in expr.elements],
         )
 
 
@@ -447,9 +444,9 @@ class Table(_IterationFunction):
 
     summary_text = "make a table of values of an expression"
 
-    def get_result(self, items):
+    def get_result(self, elements) -> ListExpression:
         return ListExpression(
-            *items,
+            *elements,
             elements_properties=ElementsProperties(elements_fully_evaluated=True),
         )
 

mathics/builtin/list/eol.py

@@ -31,27 +31,35 @@
 from mathics.builtin.base import MessageException
 from mathics.builtin.box.inout import RowBox
 
-from mathics.core.expression import Expression
 from mathics.core.atoms import Integer, Integer0, Integer1
+from mathics.core.attributes import (
+    hold_first,
+    hold_rest,
+    n_hold_rest,
+    protected,
+    read_protected,
+)
+from mathics.core.expression import Expression
 from mathics.core.list import ListExpression, to_mathics_list
+from mathics.core.rules import Rule
 from mathics.core.symbols import Atom, Symbol, SymbolNull, SymbolTrue
 from mathics.core.systemsymbols import (
     SymbolAppend,
+    SymbolByteArray,
     SymbolFailed,
+    SymbolInfinity,
     SymbolMakeBoxes,
+    SymbolMissing,
     SymbolSequence,
     SymbolSet,
 )
 
-from mathics.core.rules import Rule
-
-from mathics.core.attributes import (
-    hold_first,
-    hold_rest,
-    n_hold_rest,
-    protected,
-    read_protected,
-)
+SymbolAppendTo = Symbol("AppendTo")
+SymbolDeleteCases = Symbol("DeleteCases")
+SymbolDrop = Symbol("Drop")
+SymbolPrepend = Symbol("Prepend")
+SymbolPrependTo = Symbol("PrependTo")
+SymbolTake = Symbol("Take")
 
 
 class Append(Builtin):
@@ -96,8 +104,8 @@ def apply(self, expr, item, evaluation):
 class AppendTo(Builtin):
     """
     <dl>
-    <dt>'AppendTo[$s$, $item$]'
-        <dd>append $item$ to value of $s$ and sets $s$ to the result.
+    <dt>'AppendTo[$s$, $elem$]'
+        <dd>append $elem$ to value of $s$ and sets $s$ to the result.
     </dl>
 
     >> s = {};
@@ -129,19 +137,21 @@ class AppendTo(Builtin):
         "rvalue": "`1` is not a variable with a value, so its value cannot be changed.",
     }
 
-    def apply(self, s, item, evaluation):
-        "AppendTo[s_, item_]"
+    def apply(self, s, element, evaluation):
+        "AppendTo[s_, element_]"
         resolved_s = s.evaluate(evaluation)
         if s == resolved_s:
             return evaluation.message("AppendTo", "rvalue", s)
 
         if not isinstance(resolved_s, Atom):
             result = Expression(
-                SymbolSet, s, Expression(SymbolAppend, resolved_s, item)
+                SymbolSet, s, Expression(SymbolAppend, resolved_s, element)
             )
             return result.evaluate(evaluation)
 
-        return evaluation.message("AppendTo", "normal", Expression("AppendTo", s, item))
+        return evaluation.message(
+            "AppendTo", "normal", Expression(SymbolAppendTo, s, element)
+        )
 
 
 class Cases(Builtin):
@@ -317,21 +327,21 @@ def apply_ls_n(self, items, pattern, levelspec, n, evaluation):
 
         levelspec = python_levelspec(levelspec)
 
-        if n is Symbol("Infinity"):
+        if n is SymbolInfinity:
             n = -1
         elif n.get_head_name() == "System`Integer":
             n = n.get_int_value()
             if n < 0:
                 evaluation.message(
                     "DeleteCases",
                     "innf",
-                    Expression("DeleteCases", items, pattern, levelspec, n),
+                    Expression(SymbolDeleteCases, items, pattern, levelspec, n),
                 )
         else:
             evaluation.message(
                 "DeleteCases",
                 "innf",
-                Expression("DeleteCases", items, pattern, levelspec, n),
+                Expression(SymbolDeleteCases, items, pattern, levelspec, n),
             )
             return SymbolNull
 
@@ -401,11 +411,11 @@ class Drop(Builtin):
      = Drop[{1, 2, 3, 4, 5, 6}, {-5, -2, -2}]
     """
 
-    summary_text = "remove a number of elements from a list"
     messages = {
         "normal": "Nonatomic expression expected at position `1` in `2`.",
         "drop": "Cannot drop positions `1` through `2` in `3`.",
     }
+    summary_text = "remove a number of elements from a list"
 
     def apply(self, items, seqs, evaluation):
         "Drop[items_, seqs___]"
@@ -414,7 +424,7 @@ def apply(self, items, seqs, evaluation):
 
         if isinstance(items, Atom):
             return evaluation.message(
-                "Drop", "normal", 1, Expression("Drop", items, *seqs)
+                "Drop", "normal", 1, Expression(SymbolDrop, items, *seqs)
             )
 
         try:
@@ -633,7 +643,7 @@ def check_pattern(input_list, pat, result, beginLevel):
         if is_found:
             return to_mathics_list(*result)
         else:
-            return Expression("Missing", "NotFound") if default is None else default
+            return Expression(SymbolMissing, "NotFound") if default is None else default
 
     def apply_default(self, expr, pattern, default, evaluation):
         "FirstPosition[expr_, pattern_, default_]"
@@ -957,7 +967,7 @@ def apply(self, list, i, evaluation):
             if idx.get_head_name() == "System`Integer":
                 idx = idx.get_int_value()
                 if idx == 0:
-                    return Symbol("System`ByteArray")
+                    return SymbolByteArray
                 data = list.elements[0].value
                 lendata = len(data)
                 if idx < 0:
@@ -1130,11 +1140,13 @@ def apply(self, s, item, evaluation):
             return evaluation.message("PrependTo", "rvalue", s)
 
         if not isinstance(resolved_s, Atom):
-            result = Expression("Set", s, Expression("Prepend", resolved_s, item))
+            result = Expression(
+                SymbolSet, s, Expression(SymbolPrepend, resolved_s, item)
+            )
             return result.evaluate(evaluation)
 
         return evaluation.message(
-            "PrependTo", "normal", Expression("PrependTo", s, item)
+            "PrependTo", "normal", Expression(SymbolPrependTo, s, item)
         )
 
 
@@ -1302,8 +1314,8 @@ def apply(self, items, expr, evaluation):
             evaluation.message("Select", "normal")
             return
 
-        def cond(leaf):
-            test = Expression(expr, leaf)
+        def cond(element):
+            test = Expression(expr, element)
             return test.evaluate(evaluation) is SymbolTrue
 
         return items.filter(items.head, cond, evaluation)
@@ -1421,7 +1433,7 @@ def apply(self, items, seqs, evaluation):
 
         if isinstance(items, Atom):
             return evaluation.message(
-                "Take", "normal", 1, Expression("Take", items, *seqs)
+                "Take", "normal", 1, Expression(SymbolTake, items, *seqs)
             )
 
         try:

mathics/builtin/numbers/algebra.py

@@ -1596,7 +1596,9 @@ def apply_with_assumptions(self, expr, assum, evaluation, options={}):
             SymbolList
         )
         # Now, reevaluate the expression with all the assumptions.
-        simplify_expr = Expression(self.get_name(), expr, *options_to_rules(options))
+        simplify_expr = Expression(
+            Symbol(self.get_name()), expr, *options_to_rules(options)
+        )
         return dynamic_scoping(
             lambda ev: simplify_expr.evaluate(ev),
             {"System`$Assumptions": assumptions},

mathics/builtin/numbers/diffeqns.py

@@ -6,10 +6,11 @@
 
 import sympy
 from mathics.builtin.base import Builtin
-from mathics.core.expression import Expression
 from mathics.core.convert import from_sympy
+from mathics.core.expression import Expression
+from mathics.core.list import ListExpression
 from mathics.core.symbols import Atom, Symbol
-from mathics.core.systemsymbols import SymbolFunction
+from mathics.core.systemsymbols import SymbolFunction, SymbolRule
 
 
 class DSolve(Builtin):
@@ -134,7 +135,7 @@ def apply(self, eqn, y, x, evaluation):
             func = y
         except AttributeError:
             func = Expression(y, *syms)
-            function_form = Expression("List", *syms)
+            function_form = ListExpression(*syms)
 
         if isinstance(func, Atom):
             evaluation.message("DSolve", "dsfun", y)
@@ -180,21 +181,18 @@ def apply(self, eqn, y, x, evaluation):
                 sym_result = [sym_result]
 
         if function_form is None:
-            return Expression(
-                "List",
+            return ListExpression(
                 *[
-                    Expression("List", Expression("Rule", *from_sympy(soln).leaves))
+                    ListExpression(Expression(SymbolRule, *from_sympy(soln).elements))
                     for soln in sym_result
                 ]
             )
         else:
-            return Expression(
-                "List",
+            return ListExpression(
                 *[
-                    Expression(
-                        "List",
+                    ListExpression(
                         Expression(
-                            "Rule",
+                            SymbolRule,
                             y,
                             Expression(
                                 SymbolFunction,
@@ -214,9 +212,8 @@ def apply(self, eqn, y, x, evaluation):
 class C(Builtin):
     """
     <dl>
-    <dt>'C'[$n$]
-        <dd>represents the $n$th constant in a solution to a
-        differential equation.
+      <dt>'C'[$n$]
+      <dd>represents the $n$th constant in a solution to a differential equation.
     </dl>
     """