* using is_uniform property in matching SequenceBlank and SequenceNullBlank patterns

* `get_result` now accepts an optional attribute `is_uniform` to set this property in its result.

* `Table`, `Sum` and `Product` now set the element_property `is_uniform` to provide a faster evaluation of large lists.

* convert_expression_elements now handles is_uniform

Author: mmatera

mathics/builtin/arithmetic.py

@@ -42,7 +42,7 @@
     Test,
 )
 from mathics.core.convert.sympy import SympyExpression, from_sympy, sympy_symbol_prefix
-from mathics.core.element import BaseElement
+from mathics.core.element import BaseElement, ElementsProperties
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.expression_predefined import (
@@ -783,8 +783,12 @@ class Product(IterationFunction, SympyFunction, PrefixOperator):
     sympy_name = "Product"
     throw_iterb = False
 
-    def get_result(self, elements):
-        return Expression(SymbolTimes, *elements)
+    def get_result(self, elements, is_uniform=False):
+        return Expression(
+            SymbolTimes,
+            *elements,
+            elements_properties=ElementsProperties(is_uniform=is_uniform),
+        )
 
     def to_sympy(self, expr, **kwargs):
         if expr.has_form("Product", 2) and expr.elements[1].has_form("List", 3):
@@ -1020,8 +1024,12 @@ class Sum(IterationFunction, SympyFunction, PrefixOperator):
     # Do not throw warning message for symbolic iteration bounds
     throw_iterb = False
 
-    def get_result(self, elements) -> Expression:
-        return Expression(SymbolPlus, *elements)
+    def get_result(self, elements, is_uniform=False) -> Expression:
+        return Expression(
+            SymbolPlus,
+            *elements,
+            elements_properties=ElementsProperties(is_uniform=is_uniform),
+        )
 
     def to_sympy(self, expr, **kwargs) -> Optional[SympyExpression]:
         """

mathics/builtin/list/constructing.py

@@ -566,10 +566,12 @@ class Table(IterationFunction):
 
     summary_text = "make a table of values of an expression"
 
-    def get_result(self, elements) -> ListExpression:
+    def get_result(self, elements, is_uniform=False) -> ListExpression:
         return ListExpression(
             *elements,
-            elements_properties=ElementsProperties(elements_fully_evaluated=True),
+            elements_properties=ElementsProperties(
+                elements_fully_evaluated=True, is_uniform=is_uniform
+            ),
         )
 
 

mathics/builtin/patterns/basic.py

@@ -19,15 +19,15 @@
     BLANKSEQUENCE_GENERAL_PATTERN_SORT_KEY,
     BLANKSEQUENCE_WITH_PATTERN_PATTERN_SORT_KEY,
 )
-from mathics.core.symbols import BaseElement
+from mathics.core.symbols import BaseElement, Symbol
 
 # This tells documentation how to sort this module
 sort_order = "mathics.builtin.rules-and-patterns.basic"
 
 
 class _Blank(PatternObject, ABC):
     arg_counts = [0, 1]
-
+    target_head: OptionalType[Symbol]
     _instance = None
 
     def __new__(cls, *args, **kwargs):
@@ -49,12 +49,14 @@ def init(
     ) -> None:
         super().init(expr, evaluation=evaluation)
         if expr.elements:
-            self.head = expr.elements[0]
+            target_head = expr.elements[0]
+            assert isinstance(target_head, Symbol)
+            self.target_head = target_head
         else:
             # FIXME: elswhere, some code wants to
             # get the attributes of head.
             # So is this really the best thing to do here?
-            self.head = None
+            self.target_head = None
 
 
 class Blank(_Blank):
@@ -104,8 +106,9 @@ def match(self, expression: BaseElement, pattern_context: dict):
         yield_func = pattern_context["yield_func"]
 
         if not expression.has_form("Sequence", 0):
-            if self.head is not None:
-                if expression.get_head().sameQ(self.head):
+            target_head = self.target_head
+            if target_head is not None:
+                if expression.get_head() is target_head:
                     yield_func(vars_dict, None)
             else:
                 yield_func(vars_dict, None)
@@ -157,19 +160,25 @@ class BlankNullSequence(_Blank):
 
     def match(self, expression: Expression, pattern_context: dict):
         """Match with a BlankNullSequence"""
-        vars_dict = pattern_context["vars_dict"]
-        yield_func = pattern_context["yield_func"]
-        elements = expression.get_sequence()
-        if self.head:
-            ok = True
+
+        target_head = self.target_head
+        if target_head:
+            elements = expression.get_sequence()
+            is_uniform = False
+            if isinstance(expression, Expression):
+                element_properties = expression.elements_properties
+                if element_properties is not None:
+                    is_uniform = element_properties.is_uniform
             for element in elements:
-                if element.get_head() != self.head:
-                    ok = False
+                if target_head is not element.get_head():
+                    return
+                # If the expression is uniform, further checks are not necesary.
+                if is_uniform:
                     break
-            if ok:
-                yield_func(vars_dict, None)
-        else:
-            yield_func(vars_dict, None)
+
+        vars_dict = pattern_context["vars_dict"]
+        yield_func = pattern_context["yield_func"]
+        yield_func(vars_dict, None)
 
     @property
     def element_order(self) -> tuple:
@@ -240,21 +249,28 @@ class BlankSequence(_Blank):
     summary_text = "match to a non-empty sequence of elements"
 
     def match(self, expression: Expression, pattern_context: dict):
-        vars_dict = pattern_context["vars_dict"]
-        yield_func = pattern_context["yield_func"]
         elements = expression.get_sequence()
+
         if not elements:
             return
-        if self.head:
-            ok = True
+
+        target_head = self.target_head
+        if target_head:
+            is_uniform = False
+            if isinstance(expression, Expression):
+                element_properties = expression.elements_properties
+                if element_properties is not None:
+                    is_uniform = element_properties.is_uniform
             for element in elements:
-                if element.get_head() != self.head:
-                    ok = False
+                if target_head is not element.get_head():
+                    return
+                # If the expression is uniform, further checks are not necesary.
+                if is_uniform:
                     break
-            if ok:
-                yield_func(vars_dict, None)
-        else:
-            yield_func(vars_dict, None)
+
+        vars_dict = pattern_context["vars_dict"]
+        yield_func = pattern_context["yield_func"]
+        yield_func(vars_dict, None)
 
     def get_match_count(self, vars_dict: OptionalType[dict] = None) -> tuple:
         return (1, None)

mathics/builtin/procedural.py

@@ -309,7 +309,7 @@ class Do(IterationFunction):
     allow_loopcontrol = True
     summary_text = "evaluate an expression looping over a variable"
 
-    def get_result(self, _items):
+    def get_result(self, _items, is_uniform=False):
         return SymbolNull
 
 

mathics/core/builtin.py

@@ -1023,7 +1023,7 @@ class IterationFunction(Builtin, ABC):
     allow_loopcontrol = False
     throw_iterb = True
 
-    def get_result(self, elements) -> Expression:
+    def get_result(self, elements, is_uniform=False) -> Expression:
         raise NotImplementedError
 
     def eval_symbol(self, expr, iterator, evaluation):
@@ -1159,6 +1159,8 @@ def eval_iter(self, expr, i, imin, imax, di, evaluation):
         ).evaluate(evaluation)
 
         result = []
+        last_head = None
+        is_uniform = True
         while True:
             cont = Expression(SymbolLessEqual, index, normalised_range).evaluate(
                 evaluation
@@ -1186,6 +1188,10 @@ def eval_iter(self, expr, i, imin, imax, di, evaluation):
                     evaluation,
                 )
                 result.append(item)
+                if last_head is None:
+                    last_head = item.get_head()
+                elif is_uniform and last_head is not item.get_head():
+                    is_uniform = False
             except ContinueInterrupt:
                 if self.allow_loopcontrol:
                     pass
@@ -1202,7 +1208,7 @@ def eval_iter(self, expr, i, imin, imax, di, evaluation):
                 else:
                     raise
             index = Expression(SymbolPlus, index, Integer1).evaluate(evaluation)
-        return self.get_result(result)
+        return self.get_result(result, is_uniform=is_uniform)
 
     def eval_list(self, expr, i, items, evaluation):
         "%(name)s[expr_, {i_Symbol, {items___}}]"

mathics/core/expression.py

@@ -1981,7 +1981,8 @@ def convert_expression_elements(
 
     # All of the properties start out optimistic (True) and are reset when that
     # proves wrong.
-    elements_properties = ElementsProperties(True, True, True)
+    # Also, expressions from this function are expected to be uniform.
+    elements_properties = ElementsProperties(True, True, True, True)
 
     is_literal = True
     values = []  # If is_literal, "values" contains the (Python) literal values