Halting Symbol Transformations for Function Arguments

Question

I think the simplest way to state my question is to give an example:

x=2;
f[x_]:= x;

(* Is this possible? *)
f[x]
(* x *)

In other words, is it possible to stop Mathematica from evaluating x as 2 before evaluating the function? None of the Hold attributes or functions have successfully halted this part of evaluation for me.

What I'm trying to do is pass symbols to a function for it to manipulate, but I don't want to worry about the same symbol names being used in other parts of the code. Using Clear works, but it then requires me to re-evaluate the areas where the symbol name was used before, so I was hoping there was an easier way other than clearing or using different symbol names.

Edit: Sorry for the confusion. m_goldberg correctly guessed what I was trying to explain. Although I can hide global variables in Module blocks by using the same variable names, I was hoping for the same results with a function. Here is his code that represents my goal:

x = 2;
SetAttributes[f,HoldFirst]
f[x_]:= Module[{u = Defer[x]}, 1 + u + u^2];

f[x]

1 + x + x^2

In other words, I wanted to arbitrarily pick symbols as arguments to a function, regardless if they had been assigned values prior to calling my function. Apparently, I was looking for Defer.

I think it's worth noting that jjc385's answer also achieved my goal, but with a hold on the result.

Thank you everybody for the help!

Answer 1

Perhaps this is what you are looking for.

The normal evaluation of arguments can be overridden by giving a function the appropriate Hold... attribute.

x = 2;
SetAttributes[f, HoldFirst]
f[x_] := Module[{u = Defer[x]}, 1 + u + u^2]

f[x]

1 + x + x^2

Answer 2

It's not entirely clear what you want, but perhaps this is a start.

Based on your comment, it seems like you may be roughly trying to mimic the behavior of either Module or Block :

(* x, y already have explicit values *)
x=1;
y=2;

Module[{x, y},
 First @ Solve[{x + y == 5, x - y == 1}, {x, y}]
]

{3, 2}

If the returned expression doesn't depend on any of the previously defined variables (as is the case above), Module and Block should give you the same output.

If the returned expression does depend on the previously defined variables, neither output may be desirable:

(* x, y already have explicit values *)
x=1;
y=2;

Module[{x, y},
 First @ Solve[{x + y == 5, x - y == 1}, {x, y}]
]

{x$9834 -> 3, y$9834 -> 2}

Block[{x, y},
 First @ Solve[{x + y == 5, x - y == 1}, {x, y}]
]

{1 -> 3, 2 -> 2}

I'm guessing you won't ever want the Block-style output. You can mitigate this using Hold:

Block[{x, y},
 Hold @@ {First @ Solve[{x + y == 5, x - y == 1}, {x, y}]}
]

Hold[{x -> 3, y -> 2}]

You can see I've used the trick of Applying (@@ing) Hold to {expr}, so that expr evaluates before getting wrapping in Hold.

You can turn this into a function using something like

ClearAll[myBlock]
SetAttributes[myBlock, HoldAll]

myBlock[varList_List, expr_] :=
 Block[varList,
  Hold @@ {expr}
 ]

Then you can do what you asked for in your original question, albeit with a Hold wrapper:

myBlock[{x}, f[x]]

 Hold[x]