removing comment/discussion about eval_ methids

Author: mmatera

mathics/eval/arithmetic.py

@@ -256,6 +256,13 @@ def eval_Sign(expr: BaseElement) -> Optional[BaseElement]:
     """
     if expr is a number, return its sign.
     """
+    sympy_expr = expr.to_sympy()
+    if sympy_expr is not None:
+        print("   sympy_expr", sympy_expr)
+        result = from_sympy(sympy.sign(sympy_expr))
+        if result is not None:
+            return result
+    return None
 
     def eval_complex_sign(n: BaseElement) -> Optional[BaseElement]:
         if isinstance(n, Complex):
@@ -694,36 +701,6 @@ def eval_Times(*items: BaseElement) -> BaseElement:
     )
 
 
-# Here I used the convention of calling eval_* to functions that can produce a new expression, or None
-# if the result can not be evaluated, or is trivial. For example, if we call eval_Power_number(Integer2, RationalOneHalf)
-# it returns ``None`` instead of ``Expression(SymbolPower, Integer2, RationalOneHalf)``.
-# The reason is that these functions are written to be part of replacement rules, to be applied during the evaluation process.
-# In that process, a rule is considered applied if produces an expression that is different from the original one, or
-# if the replacement function returns (Python's) ``None``.
-#
-# For example, when the expression ``Power[4, 1/2]`` is evaluated, a (Builtin) rule  ``Power[base_, exp_]->eval_repl_rule(base, expr)``
-# is applied. If the rule matches, `repl_rule` is called with arguments ``(4, 1/2)`` and produces `2`. As `Integer2.sameQ(Power[4, 1/2])`
-# is False, then no new rules for `Power` are checked, and a new round of evaluation is atempted.
-#
-# On the other hand, if ``Power[3, 1/2]``, ``repl_rule`` can do two possible things: one is return ``Power[3, 1/2]``. If it does,
-# the rule is considered applied. Then, the evaluation method checks if `Power[3, 1/2].sameQ(Power[3, 1/2])`. In this case it is true,
-# and then the expression is kept as it is.
-# The other possibility is to return  (Python's) `None`. In that case, the evaluator considers that the rule failed to be applied,
-# and look for another rule associated to ``Power``. To return ``None`` produces then a faster evaluation, since no ``sameQ`` call is needed,
-# and do not prevent that other rules are attempted.
-#
-# The bad part of using ``None`` as a return is that I would expect that ``eval`` produces always a valid Expression, so if at some point of
-# the code I call ``eval_Power_number(Integer3, RationalOneHalf)`` I get ``Expression(SymbolPower, Integer3, RationalOneHalf)``.
-#
-# From my point of view, it would make more sense to use the following convention:
-#  * if the method has signature ``eval_method(...)->BaseElement:`` then use the prefix ``eval_``
-#  * if the method has the siguature ``apply_method(...)->Optional[BaseElement]`` use the prefix ``apply_`` or maybe ``repl_``.
-#
-# In any case, let's keep the current convention.
-#
-#
-
-
 def associate_powers(expr: BaseElement, power: BaseElement = Integer1) -> BaseElement:
     """
     base^a^b^c^...^power -> base^(a*b*c*...power)