Local variables

Question

I'm trying to use Modules together with functions.

tmp2 = x^2 + 1; f[y_] := Module[{x = 1}, Evaluate[y tmp2]]

This works when I just have

tmp2 = x^2 + 1; Module[{x = 1}, Evaluate[tmp2]]

But f[1] outputs $1 + x^2$.

Edit: After seeing the answers I wonder how I can get something like this to work:

ClearAll[withRules]
SetAttributes[withRules, HoldAll]
withRules[rules_, expr_] := 
 Internal`InheritedBlock[{Rule, RuleDelayed}, 
  SetAttributes[{Rule, RuleDelayed}, HoldFirst];
  Unevaluated[expr] /. rules]
ClearAll[f, tmp2]
tmp2[y_] = y (x^2 + 1)
withRules[{expr -> tmp2}, f[y_] := Module[{x = 1}, expr[y]]]

Edit 2: Maybe it is better if I explain what I'd like to do.

I have a lot of calculations in terms of $k_x$, $k_y$ and $k_z$. So, those are outputted in terms of these three variables. However, sometimes I need to integrate such expressions but to do this I need to use spherical coordinates. So I set $k_x = k \sin(a) \cos(b)$ and so on and then integrate. I don't want the transformations always set because I want the other calculations to have $k_x$, $k_y$ and $k_z$ as variables, not $a$ en $b$.

Answer 1

Ok, let me tell you straight away that what you are trying to do is likely to be a bad idea. Now, let me explain. The problem you face on the surface is that Evaluate is only effective at the first level inside heads which hold their arguments. Since you have SetDelayed[f[y_],Module[...]], the stuff inside Module is too deep. You need With to inject arbitrarily deep, so we try:

ClearAll[f, x];
With[{tmp = tmp2},
   f[y_] := Module[{x = 1}, y tmp]] 

However, now you face another problem: variable renaming mechanism in scoping constructs tries to protect the scoping and renames variables in part of your code:

?f
Global`f
f[y$_]:=Module[{x$=1},y$ (1+x^2)]

Here is what you can do to achieve your goal:

ClearAll[f, x];
Block[{tmp}, Unevaluated[f[y_] := Module[{x = 1}, y*tmp]] /. tmp -> tmp2]

This is explained in details here. Note however that the fact that we had to go against the system twice tells us already that this is a fragile and generally bad practice. Please see more discussion on that in the linked answer.

EDIT

In response to the edit in the question: in your case, I suggest to use Block and create a dynamic environment, where to execute the code for which you do want your transformations:

SetAttributes[withTransforms,HoldAll];
withTransforms[code_]:=
 Block[{kx=k*Sin[a]*Cos[b],ky=k*Sin[a]*Sin[b],kz=k*Cos[b]},
   code
 ]

This will allow you to selectively enable these definitions:

withTransforms[Integrate[kx^2+ky^2,{a,0,2 Pi}]]

Answer 2

What you are trying to do is generate code (a function definition) programmatically.

There are several techniques to programmatically generate code. The main tool we need is injecting held expressions into other held expression. The usual way to do it is using With:

tmp2 = x^2 + 1;

With[{expr = tmp2},
 f[y_] := Module[{x = 1}, y expr]
]

Now let's check the function definition:

?f

Global`f
f[y$_]:=Module[{x$=1},y$ (1+x^2)]

You can see that Mathematica's localization mechanism has renamed x to x$ in Module, so this didn't work.

In these situations we can usually use some solution based on Replace or ReplaceAll.

It's advantageous to have this packaged up into a function. I tend to use the withRules function that I described here:

ClearAll[withRules]
SetAttributes[withRules, HoldAll]
withRules[rules_, expr_] :=
  First@PreemptProtect@Internal`InheritedBlock[
    {Rule, RuleDelayed},
    SetAttributes[{Rule, RuleDelayed}, HoldFirst];
    Hold[expr] /. rules
]

It is used in a similar way to With, but is does not localize variables like With does.

Clear[f]
withRules[{expr -> tmp2},
 f[y_] := Module[{x = 1}, y expr]
]

Checking the definition of f again we can see that now it is what we intended:

?f

Global`f
f[y_]:=Module[{x=1},y (1+x^2)]

I have asked a related question recently, and in that post you'll find a slightly more general expression injection function (inject[]), as well as several other expression injection techniques described in the answers:

• Injecting a sequence of expressions into a held expression