cache_expr to Definitions

Author: mmatera

mathics/builtin/datentime.py

@@ -211,9 +211,9 @@ class Timing(Builtin):
 
     def apply(self, expr, evaluation):
         "Timing[expr_]"
-        evaluation.cache_result = False
         start = time.process_time()
         result = expr.evaluate(evaluation)
+        evaluation.cache_result = False      
         stop = time.process_time()
         return Expression("List", Real(stop - start), result)
 

mathics/builtin/system.py

@@ -626,18 +626,18 @@ class ClearSystemCache(Builtin):
     def apply_clear(self, evaluation):
         "ClearSystemCache[]"
         evaluation.cache_result = False
-        evaluation.cache_expr = {}
+        evaluation.definitions.cache_eval = {}
         return
 
     def apply_clear_symbolic(self, evaluation):
         'ClearSystemCache["Symbolic"]'
         evaluation.cache_result = False
-        evaluation.cache_expr = {}
+        evaluation.definitions.cache_eval = {}
         return
 
     def apply_clear_numeric(self, evaluation):
         'ClearSystemCache["Numeric"]'
         evaluation.cache_result = False
-        evaluation.cache_expr = {}
+        evaluation.definitions.cache_eval = {}
         return
 

mathics/core/definitions.py

@@ -84,6 +84,7 @@ def __init__(
         self.proxy = defaultdict(set)
         self.now = 0  # increments whenever something is updated
         self._packages = []
+        self.cache_eval = {}
 
         if add_builtin:
             from mathics.builtin import modules, contribute

mathics/core/evaluation.py

@@ -238,7 +238,6 @@ def __init__(
     ) -> None:
         from mathics.core.definitions import Definitions
         from mathics.core.expression import Symbol
-
         if definitions is None:
             definitions = Definitions()
         self.definitions = definitions
@@ -334,11 +333,13 @@ def evaluate():
                 self.last_eval = Expression("System`$Pre", query).evaluate(self)
             else:
                 self.last_eval = query.evaluate(self)
-
             if check_io_hook("System`$Post"):
                 self.last_eval = Expression("System`$Post", self.last_eval).evaluate(
                     self
                 )
+            # From there, it is all about format. Do not catch evaluations.
+            self.cache_result = False
+
             if history_length > 0:
                 if self.predetermined_out is not None:
                     out_result = self.predetermined_out

mathics/core/expression.py

@@ -1319,12 +1319,12 @@ def evaluate(self, evaluation) -> typing.Union["Expression", "Symbol"]:
         # of a branch. Once it is set to false, the result is not cached,
         # and hence, not used.
         if evaluation.cache_result:
-            expr_hash = self.__hash__()
+            expr_hash = str(self.__hash__())
         else:
             expr_hash = None
 
         if expr_hash:
-            cache_expr_result = evaluation.cache_eval.get(expr_hash, None)
+            cache_expr_result = evaluation.definitions.cache_eval.get(expr_hash, None)
             if cache_expr_result is not None:
                 expr = cache_expr_result[0]
                 if not expr.has_changed(definitions):
@@ -1342,7 +1342,6 @@ def evaluate(self, evaluation) -> typing.Union["Expression", "Symbol"]:
 
                 if hasattr(expr, "options") and expr.options:
                     evaluation.options = expr.options
-
                 expr, reevaluate = expr.evaluate_next(evaluation)
                 if not reevaluate:
                     break
@@ -1372,7 +1371,8 @@ def evaluate(self, evaluation) -> typing.Union["Expression", "Symbol"]:
             evaluation.dec_recursion_depth()
 
         if evaluation.cache_result:
-            evaluation.cache_eval[expr_hash] = (self, expr)
+            self._timestamp_cache(evaluation)
+            evaluation.definitions.cache_eval[expr_hash] = (self, expr)
         return expr
 
     def evaluate_next(self, evaluation) -> typing.Tuple["Expression", bool]:
@@ -1426,7 +1426,6 @@ def eval_range(indices):
             evaluation.cache_result = up_cache_result
 
             # rest_range(range(0, 0))
-
         new = Expression(head)
         new._leaves = tuple(leaves)
 
@@ -1497,7 +1496,7 @@ def rules():
         for rule in rules():
             result = rule.apply(new, evaluation, fully=False)
             if result is not None:
-                evaluation.cache_result = cache_result
+                evaluation.cache_result = cache_result and evaluation.cache_result
                 if isinstance(result, BoxConstruct):
                     return result, False
                 if result.sameQ(new):
@@ -1522,6 +1521,7 @@ def rules():
         new.unformatted = self.unformatted
         new._timestamp_cache(evaluation)
         evaluation.cache_result = cache_result
+
         return new, False
 
     def evaluate_leaves(self, evaluation) -> "Expression":
@@ -1531,7 +1531,7 @@ def evaluate_leaves(self, evaluation) -> "Expression":
         for leaf in self._leaves:
             leaves.append(leaf.evaluate(evaluation))
             cache_result = cache_result and evaluation.cache_result
-            evaluation.cache_result = up_cache_result        
+            evaluation.cache_result = up_cache_result
         head = self._head.evaluate_leaves(evaluation)
         evaluation.cache_result = cache_result and evaluation.cache_result
         return Expression(head, *leaves)