“Strange” behavior of Rule

Question

According to the Help

lhs->rhs evaluates rhs immediately.

How to understand the output of the following code?

ClearAll@x;
{1, 3.5} /. x_?IntegerQ -> {x}

Output is

{{1},3.5}

Since Mathematica evaluate the rhs immediately, I think the “correct” output should be this

{{x},3.5}

And of course, if x has OwnValues, the output will be changed.

x=”why”;
{1, 3.5} /. x_?IntegerQ -> {x}

Output is

{{"why"},3.5}

As expected.

In my opinion, the two examples expose the contradictions.

In the first one, Rule behaves like RuleDelayed; it relates the local x with global x. (The color of the two variables in front-end tells me this.) But in the second one, Rule makes a clear distinction between the local and global. (There are also something similar between Set and SetDelayed)

Why does this happen? Did I misunderstand the mechanism?

Update

What I'm really confusing is Why sometimes Mathematica does not distinguish the global x and the local x in Rule.

Solution

As Aky has metioned in his comments and answer. The documentiation says,

Symbols that occur as pattern names in lhs are treated as local to the rule. This is true when the symbols appear on the right-hand side of /; conditions in lhs , and when the symbols appear anywhere in rhs , even inside other scoping constructs.

So if x doesn't have OwnValues, then the Head of x is Symbol and the name of x is the same as pattern name, as the documentation said , Mathematica will treat the two 'x's as the same. If x has OwnValues,take x=y for example, (Head of y is also Symbol) Even if x (actually y) is Symbol, the "name" of x is y which is different from the pattern name.

So in the following case,

x=y;
{1,3.5}/.x_?IntegerQ->{x}

Mathematica will return {{y},3.5} not {{1},3.5}.

Thanks for everyone's attention:)

Answer 1

I don't think there's a contradiction.

The documentation for Rule says

Symbols that occur as pattern names in lhs are treated as local to the rule.

and as you've already pointed out,

lhs -> rhs evaluates rhs immediately

In

ClearAll@x;
{1, 3.5} /. x_?IntegerQ -> {x}

the rule's rhs evaluates first, but there's no global rule associated with x, so the rule remains as x_?IntegerQ -> {x}, and the x everywhere in the rule is local to it.

In

x = "why";
{1, 3.5} /. x_?IntegerQ -> {x}

the rule's rhs evaluates to "why", and the rule becomes x_?IntegerQ ->{"why"}.

Answer 2

Perhaps it will seem clearer if the FullForm of the rule is examined. In the first example below, we see that the value of x is the RHS of the rule. So we should expect any integer to be replaced by {2}.

x = 2;
x_?IntegerQ -> {x} // FullForm

Rule[PatternTest[Pattern[x, Blank[]], IntegerQ], List[2]]

Here, if we clear x, the RHS of the rule is {x}. As @Aky pointed out in a comment, the documentation implies that in this rule the symbol x will represent the pattern match. So we should expect any integer to be replaced by a list containing that integer.

Clear[x];
x_?IntegerQ -> {x} // FullForm

Rule[PatternTest[Pattern[x, Blank[]], IntegerQ], List[x]]

One might wish to compare the above with RuleDelayed. Even if x has an ownvalue, the RHS is {x}. So this rule will behave like the previous one.

x = 2;
x_?IntegerQ :> {x} // FullForm

RuleDelayed[PatternTest[Pattern[x, Blank[]], IntegerQ], List[x]]

Answer 3

I don't know why it works that way, and you have the same issue with f[x_]={x}. You will find code here that defines new operators that work like x_?IntegerQ->{X} and f[x_]={x} except the new operators do what you expected.

Answer 4

Note that your first example is not contradictory with the immediate evaluation of the rhs.
For example, if you try :

ClearAll[x, y]
x = y
{1, 3.5} /. y_?IntegerQ -> {x}

you get {{1}, 3.5}.

This means that the rhs is really evaluated