Handle optional with a first element that is not a Pattern[]

Author: mmatera

mathics/builtin/attributes.py

@@ -654,81 +654,6 @@ class ReadProtected(Predefined):
     summary_text = "attribute of symbols with hidden definitions"
 
 
-class Flat(Predefined):
-    """
-    <dl>
-      <dt>'Flat'
-      <dd>is an attribute that specifies that nested occurrences of
-        a function should be automatically flattened.
-    </dl>
-
-    A symbol with the 'Flat' attribute represents an associative
-    mathematical operation:
-    >> SetAttributes[f, Flat]
-    >> f[a, f[b, c]]
-     = f[a, b, c]
-
-    'Flat' is taken into account in pattern matching:
-    >> f[a, b, c] /. f[a, b] -> d
-     = f[d, c]
-
-    #> SetAttributes[{u, v}, Flat]
-    #> u[x_] := {x}
-    #> u[]
-     = u[]
-    #> u[a]
-     = {a}
-    #> u[a, b]
-     : Iteration limit of 1000 exceeded.
-     = $Aborted
-    #> u[a, b, c]
-     : Iteration limit of 1000 exceeded.
-     = $Aborted
-    #> v[x_] := x
-    #> v[]
-     = v[]
-    #> v[a]
-     = a
-    #> v[a, b] (* in Mathematica: Iteration limit of 4096 exceeded. *)
-     = v[a, b]
-    #> v[a, b, c] (* in Mathematica: Iteration limit of 4096 exceeded. *)
-     : Iteration limit of 1000 exceeded.
-     = $Aborted
-    """
-
-    summary_text = "attribute for associative symbols"
-
-
-class Orderless(Predefined):
-    """<dl>
-      <dt>'Orderless'
-      <dd>is an attribute that can be assigned to a symbol $f$ to
-        indicate that the elements $ei$ in expressions of the form
-        $f$[$e1$, $e2$, ...] should automatically be sorted into
-        canonical order. This property is accounted for in pattern
-        matching.
-    </dl>
-
-    The leaves of an 'Orderless' function are automatically sorted:
-    >> SetAttributes[f, Orderless]
-    >> f[c, a, b, a + b, 3, 1.0]
-     = f[1., 3, a, b, c, a + b]
-
-    A symbol with the 'Orderless' attribute represents a commutative
-    mathematical operation.
-    >> f[a, b] == f[b, a]
-     = True
-
-    'Orderless' affects pattern matching:
-    >> SetAttributes[f, Flat]
-    >> f[a, b, c] /. f[a, c] -> d
-     = f[b, d]
-
-    """
-
-    summary_text = "attribute for commutative symbols"
-
-
 class SequenceHold(Predefined):
     """
     <url>

mathics/core/pattern.py

@@ -393,13 +393,20 @@ def yield_head(head_vars, _):
                 elif pat_elem.get_head_name() == "System`Optional":
                     if len(pat_elem.elements) == 2:
                         pat, value = pat_elem.elements
-                        assert pat.get_head_name() == "System`Pattern"
-                        key = pat.elements[0].atom.name
+                        if pat.get_head_name() == "System`Pattern":
+                            key = pat.elements[0].atom.name
+                        else:
+                            # if the first element of the Optional
+                            # is not a `Pattern`, then we need to
+                            # store an empty element.
+                            key = ""
                         optionals[key] = value
                     elif len(pat_elem.elements) == 1:
                         pat = pat_elem.elements[0]
-                        assert pat.get_head_name() == "System`Pattern"
-                        key = pat.elements[0].atom.name
+                        if pat.get_head_name() == "System`Pattern":
+                            key = pat.elements[0].atom.name
+                        else:
+                            key = ""
                         # Now, determine the default value
                         defaultvalue_expr = Expression(
                             SymbolDefault, pattern_head, Integer(default_indx)
@@ -420,7 +427,9 @@ def yield_head(head_vars, _):
             if len(optionals) == 0:
                 return
 
-            # Load the default values in vars
+            # Remove the empty key and load the default values in vars
+            if "" in optionals:
+                del optionals[""]
             vars.update(optionals)
             # Try to match the non-optional element with the expression
             new_pattern.match(