The EXTERNAL attribute on a symbol tells the compiler not to treat the symbol as a local variable. The compiler, in turn, has to insert information in the object file telling the linker to resolve this symbol at link time (or even later, at run-time). If the external symbol is for a subroutine, it is typeless. If the external symbol is a function, its type has to be specified as well (explicitly or implicitly).

Functions as arguments are essential when working with nonlinear problems. A simple example is to solve f(x) = 0 for x, where f(x) is a nonlinear function. Such functions, especially when they cannot be built up with scalar, vector and matrix operations, need to be coded as "custom" functions.

Specifying the interface for subprograms that are arguments by writing interface blocks is useful, but a better solution is to write abstract interfaces to those subprograms in a module, and to USE the module wherever a declaration of the type and attributes of the subroutine/function is needed. For example:

MODULE FUNINTF

abstract interface

    real function fnc(x)

    real, intent(in) :: x

   end function fnc

end interface

END MODULE

...

USE FUNINTF

   procedure(fnc) :: fncA, fncB

...

declares fncA and fncB as two instances of functions with the same interface as that in the abstract interface; that is, they are both functions of type real, and take a single argument of type real with intent(IN). The compiler can now check for the number, types and INTENTs of the arguments in the invocations of these functions in the source code.

mecej4 answered your question well. I just wanted to mention that Fortran 2008 adds the ability to pass an internal procedure, one that is CONTAINed inside another procedure or main program, as an actual argument. (Passing a module procedure has been fine since Fortran 90.) Intel Fortran has supported this for many years, but some other Fortran compilers don't support it yet. For some amusing additional reading on this topic, see Doctor Fortran in "Think, Thank, Thunk"

You should be able to just use your browser's print feature. I find it works pretty well in recent FF and IE browsers.

For your question 2, you are required to call B and C with the arguments they expect. If D can see the abstract interface as mecej4 described, then the compiler will enforce that. If B and C have arguments that require the caller see an explicit interface, you'll need to provide that. The arguments you show in the JPG don't need it.

I think that you are doing too much guessing as to what happens when you use functions and subroutines as arguments. Just as we can have numeric, logical and character type variables, we can also have variables that stand for procedures. With numeric variables, we can evaluate arithmetical expressions containing them. With character variables, we can extract substrings, concatenate them, change case, etc. With procedure variables, we can invoke them either separately (CALL a subroutine) or as part of an expression (a function reference in the expression), or hand them off to other procedures as arguments that can, in turn, invoke their procedure arguments.

Here is a silly example. I have a subroutine which takes two arguments: (i) a function, and (ii) a variable to receive the value of the function. The argument of the function is NOT part of the subroutine argument list, but is set to π in the subroutine before evaluating the function. The main program calls the subroutine twice, (i) with a function that returns the square of its argument, and (ii) a function that returns the cube of its argument.

The subroutine acts as a mere forwarding agent, and does not know anything about what is done inside the functions.

Note that there is considerable flexibility as to where to do each variable assignment and each evaluation.

module funint

abstract interface

   real function f1var(x)

     real, intent(in) :: x

   end function f1var

end interface

end module funint

!

program showGenIntf

use funint

real :: yvala,yvalb

call eval(f1a,yvala)

call eval(f1b,yvalb)

write(*,*)' For x = Pi, f1a(x) = ',yvala,',  f1b(x) = ',yvalb

!

contains

!

   real function f1a(x)   ! returns square of argument

   real, intent(in) :: x

   f1a=x*x

   return

   end function f1a

!

   real function f1b(x)   ! returns cube of argument

   real, intent(in) :: x

   f1b=x*x*x

   return

   end function f1b

!

   subroutine eval(fun,fval)   ! sets fval = fun(Pi)

   procedure(f1var) :: fun

   real, intent(out) :: fval

   real :: x=acos(-1.0)

   fval=fun(x)

   return

   end subroutine eval

!

end program showGenIntf 

ABSTRACT INTERFACE is a Fortran 2003 feature that has been supported in Intel Fortran for a while now. Whose compiler are you using?