How to scope `Pattern` labels in rules/set?

Question

Module[{x},
 f@x_ = x;
 p@x_ := x;
 {x, x_, x_ -> x, x_ :> x}
 ]
?f
?p

gives

{x$17312, x$17312_, x_ -> x, x_ :> x}
f[x_]=x
p[x_]:=x

but I'd like to get

{x$17312, x$17312_, x$17312_ -> x$17312, x$17312_ :> x$17312}
f[x$17312_]=x$17312
p[x$17312_]:=x$17312

I thought Module[{x}, body_] operates something like the following, which would do what I want:

module[{x_Symbol}, body_] := ReleaseHold[Hold@body /. x -> Unique@x];
SetAttributes[module, HoldAll];

module[{x},
 f@x_ = x;
 p@x_ := x;
 {x, x_, x_ -> x, x_ :> x}
 ]
?f
?p

I guess there are some cases with nested scoping constructs that need to be considered for special treatment, but why can't it do the replacement in Set, SetDelayed, Rule, RuleDelayed?

---

Motivation

I want to usef@x_ = Integrate[y^2, {y, 0, x}] instead of f@x_ := Evaluate@Integrate[y^2, {y, 0, x}] and to be safe I want to scope the variable/pattern label x to something unique.

See also Why does syntax highlighting in `Set` and `Rule` not color pattern names on the RHS?

Answer 1

While Set isn't a scoping construct (SC), it is considered one by other SCs outer to it. ref / Set / Details[[-3]] (thanks to Alexey Popkov for correcting me).

Here it is inner to the Module and Module decides not to interfere in this case (don't know why), but you can trick it:

Module[{x},
  Set @@ {f[x_], Integrate[y^2, {y, 0, x}]};
]

?f

f[x$301_]=x$301^3/3

Further reading: Enforcing correct variable bindings and avoiding renamings for conflicting variables in nested scoping constructs

Answer 2

This issue has been discussed before in

• I define a variable as local to a module BUT then the module uses its global value! Why?

Regarding your motivation a solution of mine, which you linked to yourself, is shown in

• How to make a function like Set, but with a Block construct for the pattern names

What is left is to implement a Module alternative as you attempted, or to use some alternative to Rule, Set, etc., as shown in other answers. I shall explore making a Module alternative more robust. To pick apart your starting code:

1. Unique@x will evaluate x; this is unacceptable.

2. The local Symbol lacks the Temporary attribute and will not be garbage-collected.

3. Only a single local Symbol may be specified.

4. There is no provision for assignments within the first parameter.

Here is my attempt to fix these limitations.

SetAttributes[module, HoldAll]

clean = Replace[#, (Set | SetDelayed)[s_Symbol, _] :> s, {2}] &;

module[{sets : (_Symbol | _Set | _SetDelayed) ..}, body_] :=
 (List @@ #; 
    Unevaluated[body] /. 
     List @@ MapAt[HoldPattern, {All, 1}] @ 
       Thread[clean[Hold[sets] :> #], Hold]) & @ Module[{sets}, Hold[sets]]

Now:

x = 1;
module[{x},
  f @ x_  = x;
  p @ x_ := x;
  {x, x_, x_ -> x, x_ :> x}
]
?f
?p

{x$533, x$533_, x$533_ -> x$533, x$533_ :> x$533}

f[x$533_]=x$533

p[x$533_]:=x$533

And also:

module[{x, y = 3, z := Print["foo!"]},
  {x, y, x_, y_, x_ -> x y, x_ :> x, z_ :> x y}
]

{x$533, 3, x$533_, y$533_, x$533_ -> 3 x$533, x$533_ :> x$533, 
 z$533_ :> x$533 y$533}

Answer 3

I think a third kind of behaviour would also be possible: it is debatable whether f@x_ = x, x_ -> x within Module[{x}, ... should not become f@x_ = x$123, x_ -> x$123 because then the sequence

ClearAll[Global`x];
x = 1;
0 /. x_ -> x

would do the same whether executed in the global context or within a Module[{x}, ...]. It currently does not: With a fresh kernel (or after clearing x), the program gives 1 in the global context and 0 within a Module[{x}, ...]:

ClearAll[Global`x];
Module[{x}, x = 1; 0 /. x_ -> x]

Use Hold, Unique, ReleaseHold as you demonstrated if you want some specific renaming to happen within pattern labels of Set, SetDelayed, Rule, RuleDelayed - Module will not descend into these by design.

Answer 4

It looks like what you need is the LocalPatterns` package by Ted Ersek. It introduces new special symbols DotEqual and LongRightArrow which works like Set and Rule but provide variable scoping during evaluation of the RHS:

<< LocalPatterns.m

?DotEqual

lhs\[DotEqual]rhs evaluates rhs using a local environment for any variable used as a pattern in lhs. From then on lhs is replaced by the result of evaluating rhs whenever lhs appears. The infix operator \[DotEqual] is entered as \[DotEqual]. The expression lhs\[DotEqual]rhs, has an equivalent form LocalSet[lhs,rhs].

Clear[f];
x = 53.54;
f[x_] \[DotEqual] Integrate[Log[Sqrt[x] + 1], x]

Definition[f]

f[x_] := Sqrt[x] - x/2 + (-1 + x) Log[1 + Sqrt[x]]

?LongRightArrow

lhs → rhs represents a rule where rhs is evaluated immediately using a local environment for any variable used as a pattern in lhs. The infix operator → is entered as \[LongRightArrow]. The expression lhs → rhs has an equivalent form LocalRule[lhs,rhs].

x = 34/7;
g2 = g[x_]\[LongRightArrow]Integrate[Log[Sqrt[x] + 1], x]

g[x_] :> Sqrt[x] - x/2 + (-1 + x) Log[1 + Sqrt[x]]