Opposite of Alternatives in a Rule

Question

Mathematica provides Alternatives, to match one of several patterns. In a rule, this is used as p1|p2|p3:>replacement. I would like to have the opposite logic: p1&p2&p3:>replacement (obviously using another notation) should match if all of p1, p2, and p3 match, and replacement should be allowed to involve variables in all of p1, p2, p3.

If one is simply concerned in whether all patterns match, one can use Except[Except[p1] | Except[p2] | Except[p3]], as described in Opposite of Alternatives or Logical AND of multiple patterns. I would like to do the same with rules, but the doubel-Except construction will not populate named patterns (at least in v10.0 I get an Except::named message).

Cases[{2/3, 1 + Pi, 3 - Gamma[I], 1 + x}, 
  AndRuleDelayed[Plus[a_, b_], c_?NumericQ, {a, b, c}]]

(* should give
  {{1, Pi, 1 + Pi}, {3, -Gamma[I], 3 - Gamma[I]}}
*)

Answer 1

The following code defines AndRuleDelayed to take a number of patterns followed by a (single) replacement and build a rule. The rule matches if and only if all patterns match, and the replacement can involve variables from any of the patterns. If the same variable name appears in two patterns, the combined pattern will only match if all occurrences of that name match the same thing (exactly like Mathematica does normally in patterns like {a_,a_}).

Clear[AndRuleDelayed];
AndRuleDelayed::usage = 
  "AndRuleDelayed[p1_,p2_,...,rhs_] is p1&p2&...:>rhs.";
Begin["AndRule`"];
SetAttributes[AndRuleDelayed, HoldAll];
SyntaxInformation[AndRuleDelayed] = {"ArgumentsPattern" -> {_, __}};
AndRuleDelayed[patts__, rhs_] :=
  (total_ :>
    With[{result = 
       Cases[{Table[total, {Length[{patts}]}]}, {patts} :> rhs]},
     result[[1]] /; result =!= {}]);
End[];

(I've put the code in a scope because I suspect that there may be issues with name collisions otherwise.) Examples:

Cases[{2/3, 1 + Pi, 3 - Gamma[I], 1 + x}, 
  AndRuleDelayed[Plus[a_, b_], c_?NumericQ, {a, b, c}]]

(*=> {{1, Pi, 1 + Pi}, {3, -Gamma[I], 3 - Gamma[I]}}*)

Cases[{{5, 2, 3, 5}, {3, 4}, {6, 3, 6}}, 
  AndRuleDelayed[{___, 3, a_}, {a_, b_, ___}, l_List, 
   g[a, b, Length[l]]]]

(*=> {g[5, 2, 4], g[6, 3, 3]}*)

Answer 2

I like this question and I know I have played with the concept before, either for a question here or for my own interest. (I cannot recall.)

I also like your method but I am immediately struck by the fact that it will not work with held expressions, for example:

Hold[1 + 2] /. AndRuleDelayed[a_ + b_, c_?NumericQ, {a, b, c}]
Hold[1 + 2] /. (a_ + b_) :> {a, b, c}
Hold[1 + 2] /. c_?NumericQ :> {a, b, c}

Hold[1 + 2]

Hold[{1, 2, c}]

Hold[{a, b, 1 + 2}]

I propose this as a partial improvement:

Attributes[multiRuleD] = {HoldAll};

multiRuleD[patts__, rhs_] := total_ :>
  With[
    {result =
      Cases[
        {Join @@ (Hold[total] & /@ {patts})},
        Hold[patts] :> rhs
      ][[1]] // Quiet},
   result /; Quiet[result =!= {}[[1]]]
  ]

Now:

Hold[1 + 2] /. multiRuleD[a_ + b_, c_?NumericQ, {a, b, c}]

Hold[{1, 2, 3}]

Ideally this should have returned Hold[{1, 2, 1 + 2}] but I cannot recall a way to prevent that evaluation in a self-contained way.

Note:

• Use of Hold[total] & /@ {patts} is hackish but fun. It will cause problems if explicit Slot expressions exist within total. Since my implementation is still not complete I left it in for now. If I solve the evaluation issue above and will write my code more robustly.