How to Use a Module?

Once a module is written, its global entities (i.e., global PARAMETERs, global variables and internal functions) can be made available to other modules and programs. The program or module that wants to use a particular module must have a USE statement at its very beginning. The USE statement has one of the following forms:

Syntax

The following form is the syntax of a module:

USE  module-name

USE  module-name, ONLY: name-1, name-2, ..., name-n

Here is the meaning of these USEs:

The first indicates that the current program or module wants to use the module whose name is module-name. For example, the following main program indicates that it wants to use the content of module SomeConstants:
```
PROGRAM  MainProgram
   USE   SomeConstants
   IMPLICIT  NONE
   ..........
END PROGRAM  MainProgram
```
Once a USE is specified in a program or in a module, every global entities of that used module (i.e., PARAMETERs, variables, and internal functions) becomes available to this program or this module. For example, if module SomeConstants is:
```
MODULE  SomeConstants
   IMPLICIT  NONE
   REAL, PARAMETER :: PI = 3.1415926
   REAL, PARAMETER :: g = 980
   INTEGER         :: Counter
END MODULE  SomeConstants
```
Then, program MainProgram can access to PARAMETERs PI and g and variable Counter.
However, under many circumstances, a program or a module does not want to use everything of the used module. For example, if program MainProgram only wants to use PARAMETER PI and variable Counter and does not want to use g, then the second form becomes very useful. In this case, one should add the keyword ONLY followed by a colon :, followed by a list of names that the current program or module wants to use.
```
PROGRAM  MainProgram
   USE   SomeConstants, ONLY: PI, Counter
   IMPLICIT  NONE
   ..........
END PROGRAM  MainProgram
```
Thus, MainProgram can use PI and Counter of module SomeConstants; but, MainProgram cannot use g!
USE with ONLY: is very handy, because it could only "import" those important and vital information and "ignore" those un-wanted ones.
There is a third, not recommended form, that can help to rename the names of a module locally. If a module has a name abc, in a program with a USE, one can use a new name for abc. The way of writing this renaming is the following:
```
new-name => name-in-module
```
For example, if one wants to give a new name to Counter of module SomeConstants, one should write:
```
NewCounter => Counter
```
Thus, in a program, whenever it uses MyCounter, this program is actually using Counter of module SomeConstants.
This kind of renaming can be used with ONLY: or without ONLY:.
```
PROGRAM  MainProgram
   USE   SomeConstants, ONLY: PI, MyCounter => Counter
   IMPLICIT  NONE
   ..........
END PROGRAM  MainProgram
```
The above example wants to use PI of module SomeConstants. In this case, when program MainProgram uses PI, it actually uses the PI of module SomeConstants. Program MainProgram also uses Counter of module SomeConstants; but, in this case, since there is a renaming, when MainProgram uses MyCounter it actually uses Counter of module SomeConstants.
Renaming does not require ONLY:. In the following, MainProgram can use all contents of module SomeConstants. When MainProgram uses PI and g, it uses the PI and g of module SomeConstants; however, when MainProgram uses MyCounter, it actually uses Counter of module SomeConstants.
```
PROGRAM  MainProgram
   USE   SomeConstants, MyCounter => Counter
   IMPLICIT  NONE
   ..........
END PROGRAM  MainProgram
```
Why do we need renaming? It is simple. In your program, you may have a variable whose name is identical to an entity of a module that is being USEed. In this case, renaming the variable name would clear the ambiguity.
```
PROGRAM  MainProgram
   USE   SomeConstants, GravityConstant => g
   IMPLICIT  NONE
   INTEGER :: e, f, g
   ..........
END PROGRAM  MainProgram
```
In the above example, since MainProgram has a variable called g, which is the same as PARAMETER g in module SomeConstants. By renaming g of SomeConstants, MainProgram can use variable g for the variable and GravityConstant for the PARAMETER g in module SomeConstants.
However, renaming is not a recommended feature. You should avoid using it whenever possible.