How do you USE Fortran 90 module data
Question: Let's say you have a Fortran 90 module containing _lots_ of variables,
functions and subroutines. In your `USE` statement, which convention do you
follow:

  1. explicitly declare which variables/functions/subroutines you're using with the `, only :` syntax, such as `USE [module_name], only : variable1, variable2, ...`?
  2. Insert a blanket `USE [module_name]`?

On the one hand, the `only` clause makes the code a bit more verbose. However,
it forces you to repeat yourself in the code and if your module contains
_lots_ of variables/functions/subroutines, things begin to look unruly.

Here's an example:

    
    
    module constants
      implicit none
      real, parameter :: PI=3.14
      real, parameter :: E=2.71828183
      integer, parameter :: answer=42
      real, parameter :: earthRadiusMeters=6.38e6
    end module constants
    
    program test
    ! Option #1:  blanket "use constants"
    !  use constants
    ! Option #2:  Specify EACH variable you wish to use.
      use constants, only : PI,E,answer,earthRadiusMeters
      implicit none
    
      write(6,*) "Hello world.  Here are some constants:"
      write(6,*) PI, &
           E, &
           answer, &
           earthRadiusInMeters
    end program test
    

**Update** Hopefully someone says something like _"Fortran? Just recode it in
C#!"_ so I can down vote you.

* * *

**Update**

I like [Tim Whitcomb's answer](http://stackoverflow.com/questions/1240510/how-
do-you-use-fortran-90-module-data/1240696#1240696), which compares Fortran's
`USE modulename` with Python's `from modulename import *`. A topic which has
been on Stack Overflow before:

  * [‘import module’ or ‘from module import’](http://stackoverflow.com/questions/710551/import-module-or-from-module-import)
    * [In an answer](http://stackoverflow.com/questions/710551/import-module-or-from-module-import/710603#710603), Mark Roddy mentioned:

> don't use 'from module import *'. For any reasonable large set of code, if
> you 'import *' your will likely be cementing it into the module, unable to
> be removed. This is because it is difficult to determine what items used in
> the code are coming from 'module', making it east to get to the point where
> you think you don't use the import anymore but its extremely difficult to be
> sure.

  * [What are good rules of thumb for python imports?](http://stackoverflow.com/questions/193919/what-are-good-rules-of-thumb-for-python-imports)
    * [dbr's answer](http://stackoverflow.com/questions/193919/what-are-good-rules-of-thumb-for-python-imports/193979#193979) contains

> don't do from x import * - it makes your code very hard to understand, as
> you cannot easily see where a method came from (from x import *; from y
> import *; my_func() - where is my_func defined?)

So, I'm leaning towards a consensus of explicitly stating all the items I'm
using in a module via

    
    
    USE modulename, only : var1, var2, ...
    

And as [Stefano Borini
mentions](http://stackoverflow.com/questions/1240510/how-do-you-use-
fortran-90-module-data/1240583#1240583),

> [if] you have a module so large that you feel compelled to add ONLY, it
> means that your module is too big. Split it.


Answer: I used to just do `use modulename` \- then, as my application grew, I found it
more and more difficult to find the source to functions (without turning to
grep) - some of the other code floating around the office still uses a one-
subroutine-per-file, which has its own set of problems, but it makes it much
easier to use a text editor to move through the code and quickly track down
what you need.

After experiencing this, I've become a convert to using `use`...`only`
whenever possible. I've also started picking up Python, and view it the same
way as `from modulename import *`. There's a lot of great things that modules
give you, but I prefer to keep my global namespace tightly controlled.

