Modules and Local Variables

The Wolfram Language normally assumes that all your variables are global. This means that every time you use a name like x, the Wolfram Language normally assumes that you are referring to the same object.

Particularly when you write programs, however, you may not want all your variables to be global. You may, for example, want to use the name x to refer to two quite different variables in two different programs. In this case, you need the x in each program to be treated as a local variable.

You can set up local variables in the Wolfram Language using modules. Within each module, you can give a list of variables which are to be treated as local to the module.

Module[{x,y,},body]a module with local variables x, y,

Creating modules in the Wolfram Language.

This defines the global variable t to have value 17:
Click for copyable input
The t inside the module is local, so it can be treated independently of the global t:
Click for copyable input
The global t still has value 17:
Click for copyable input

The most common way that modules are used is to set up temporary or intermediate variables inside functions you define. It is important to make sure that such variables are kept local. If they are not, then you will run into trouble whenever their names happen to coincide with the names of other variables.

The intermediate variable t is specified to be local to the module:
Click for copyable input
This runs the function f:
Click for copyable input
The global t still has value 17:
Click for copyable input

You can treat local variables in modules just like other symbols. Thus, for example, you can use them as names for local functions, you can assign attributes to them, and so on.

This sets up a module which defines a local function f:
Click for copyable input
In this case, the local function f is just an ordinary factorial:
Click for copyable input
In this case, f is set up as a generalized factorial:
Click for copyable input

When you set up a local variable in a module, the Wolfram Language initially assigns no value to the variable. This means that you can use the variable in a purely symbolic way, even if there was a global value defined for the variable outside the module.

This uses the global value of t defined above, and so yields a number:
Click for copyable input
Here Length simply receives a number as its argument:
Click for copyable input
The local variable t has no value, so it acts as a symbol, and Expand produces the anticipated algebraic result:
Click for copyable input
Module[{x=x0,y=y0,},body]a module with initial values for local variables

Assigning initial values to local variables.

This specifies t to be a local variable, with initial value u:
Click for copyable input
This uses the definition of g:
Click for copyable input

You can define initial values for any of the local variables in a module. The initial values are always evaluated before the module is executed. As a result, even if a variable x is defined as local to the module, the global x will be used if it appears in an expression for an initial value.

The initial value of u is taken to be the global value of t:
Click for copyable input
lhs:=Module[vars,rhs/;cond]share local variables between rhs and cond

Using local variables in definitions with conditions.

When you set up /; conditions for definitions, you often need to introduce temporary variables. In many cases, you may want to share these temporary variables with the body of the righthand side of the definition. The Wolfram Language allows you to enclose the whole righthand side of your definition in a module, including the condition.

This defines a function with a condition attached:
Click for copyable input
The Wolfram Language shares the value of the local variable t between the condition and the body of the righthand side:
Click for copyable input