How do I construct a Pattern with Alternatives and PatternSequence without getting Pattern::patvar messages?

Question

Bug introduced 8.0 or earlier and persisting through 11.0 [CASE:3631078]

---

In Mathematica 8 and 9, defining this rule:

rule = 
 func[a | b, c_][PatternSequence[x_, z_] | PatternSequence[{x_}, z_]] :> {c, x, z}

leads to Pattern::patvar error messages. But it seems to apply correctly:

func[a, 2][1, 3] /. rule
(*  {2, 1, 3}  *)

In Mathematica 10, defining the rule works without error messages, but applying the rule gives Pattern::patvar error messages, although it returns the correct result.

I think I'm doing something wrong in making this pattern. Question: What is the correct way to construct it without getting error messages?

---

By the way, changing the c_ to a _ in rule makes the error go away:

rule = 
 func[a | b, _][PatternSequence[x_, z_] | PatternSequence[{x_}, z_]] :> {c, x, z}

But I need the c in the LHS because it appears in the RHS.

---

By the way #2, if I use this pattern:

rule = func[var : PatternSequence[a | b, c_]][
   PatternSequence[x_, z_] | PatternSequence[{x_}, z_]] :> {c, x, z}

General::mbox errors are generated. In Mathematica 10, the error messages reveal that c_ is getting internally converted to Pattern[1,_]

HELP!

---

EDIT

I just realized that I can define the rule like this without problems:

rule = func[a | b, c_][{x_}|x_, z_] :> {c, x, z}

But this is an unfortunate case of stripping down too much from my real case which has variable number of arguments on each side of the Alternatives, like this:

rule = 
  func[a | b, c_][PatternSequence[x_, z_] | PatternSequence[{x_, z_}]] :> {c, x, z}

This still leads to Pattern::patvar error messages.

Answer 1

It seems like a glitch in the pattern matcher, occuring whenever named patterns appear in a head and PatternSequence appears at level 1 in the body.

Null /. f_[PatternSequence[x, y]] -> 0

Pattern::patvar : First element in pattern Pattern[1, _] is not a valid pattern name. >>

When there are multiple named patterns in the head there are additional warnings with different numbers:

Off[General::stop]

Null /. f[a_, b_, c_, b_][PatternSequence[x, y]] -> 0

Pattern::patvar : First element in pattern Pattern[1, _] is not a valid pattern name. >> Pattern::patvar : First element in pattern Pattern[2, _] is not a valid pattern name. >> Pattern::patvar : First element in pattern Pattern[3, _] is not a valid pattern name. >> Pattern::patvar : First element in pattern Pattern[2, _] is not a valid pattern name. >>

Note how the numbers in the messages follow the same sequence as the pattern names. It looks like the named patterns are internally associated with integer values and somehow the presence of PatternSequence in the body causes those integers to be processed as names.

I'm pretty sure this is unexpected behaviour and should be reported to Wolfram.

Answer 2

In this case, the use of PatternSequence seems to be unnecessary. I think that the following achieves the desired result:

rule2 = HoldPattern[func[a | b, c_][({x_} | x_), z_]] :> {c, x, z}
func[a, 2][1, 3] /. rule2
func[a, 2][{1}, 3] /. rule2

In response to the edited question, I think the following works

rule3 = func[a | b, c_][{x__} | (x__)] :> {c, x}
func[a, 2][1, 3] /. rule3
func[a, 2][{1, 3}] /. rule3