How to replace a variable that was assigned a value before

Question

Question

How to make the replacement $f[x] \to f[y]$ for an abitrary function $f$ if $x$ was assigned a value before?

Example 1

How can I make the replacement $x +1 \to y + 1$ if I have assigned the variable $x$ a value before?

Problematic attempts

A first guess would be

x = 1;
x + 1 /. x -> y

4

This does not give $y + 1$ because $x + 1$ is evaluated to 4 before the replacement is attempted. I expected this would give $y+1$:

Unevaluated[1 + x] /. x -> y

4

My reasoning was that the replacement of $x$ with $y$ in

x + 1 // FullForm 
Unevaluated[1 + x] // FullForm

4

Unevaluated[Plus[1,x]]

gives '4' and Unevaluated[Plus[1,y]], but it does not. Why? Is there a solution that works in this spirit?

Working Solution

In the post Symbolic computations with already assigned variables, I found the suggestion to use block. Indeed it works

Block[{x}, x + 1 /. x -> y]

y + 1

Example 2

Let

x = {1, 3, 4};
f[x_] := Length[x];

How to replace x in f[x] with {1, 2}? We allready saw that f[x] /. x -> {1, 2} will not work. Here the construction with Block does not work either

Block[{x}, f[x] /. x -> {3, 2}

0

It gives 0 since the lefthand side of the rule is evaluated first, and gives 'Length[x] = 0'. Only then the rule is applied. I guess I need a rule in the spirit of the 'problematic attempts' in order to make the desired replacement.

Answer 1

All you need is to ensure that the replacing is done before evaluation, including the LHS of the replace rule. Here is one way to achieve that, which I think is probably the most straightforward:

x = 1;
ReleaseHold[Hold[x + 1] /. HoldPattern[x] -> y]

This will also work for your second example:

ReleaseHold[Hold[f[x]] /. HoldPattern[x] -> {3, 2}]

Using Block for similar tasks is often more elegant, but as you have learned needs to be used with some care. I usually prefer solutions which more explicitly state what they try to achieve and here what you want to do is to change the usual evaluation order which I think can be read clearly from the above lines. Here is another way suggested by Mr.Wizard which is also more elegant and achieves the same thing, again with making use of some evaluation automatisms which might not be obvious to every reader:

Unevaluated[f[x]] /. HoldPattern[x] -> {3, 2}

For more details I'd recommend to have look at "tutorial/Evaluation" in the documentation which I consider a "must know" for everyone trying to get serious work done with Mathematica...

Answer 2

As described by Albert Retey you need to hold both the expression to be operated on and the left-hand side of the replacement rule. I usually use Unevaluated:

Unevaluated[x + 1] /. HoldPattern[x] -> y

I suppose I have to at least reference this popular one:

y /. x_ :> x + 1

The x in x_ is held because it is a Pattern name and on the right because of RuleDelayed having HoldRest.

Another method that can be useful is to dynamically redefine the attributes of these functions, rather than Blocking a certain group of symbols; this therefore works for any expression without having to specify which symbols to protect.

SetAttributes[withHeldReplace, HoldAll]

withHeldReplace[expr_] :=
  With[{fns = {Replace, ReplaceAll, Rule, RuleDelayed}},
    Internal`InheritedBlock[fns,
      SetAttributes[fns, HoldFirst];
      expr
    ]
  ]

Now:

withHeldReplace[
  x + 1 /. x -> y
]

1 + y

Note: I just found an earlier use by Szabolcs of a similar method: ReplaceAll inside an Iterator

---

Here is an alternative for anyone uncomfortable with modifying the behavior of a System` function, even in a Block:

SetAttributes[withHeldReplace2, HoldAll]

withHeldReplace2[expr_] := Unevaluated[expr] /.
  (r: Rule | RuleDelayed | Replace | ReplaceAll)[lhs_, rhs__] :> r[Unevaluated[lhs], rhs]

x = 1;

withHeldReplace2[
  x + 1 /. x -> y
]

1 + y