The types in C are as follows:

	A basic: char, int, float, double;
	A structure of objects of various types;
	An array of objects of a given type;
	A function returning a thing of a specified type;
	A pointer to an object of a specified type.

The restrictions on forming types are as follows.

	A structure may not contain a function;
	An array may not consist of functions;
	A function may not return a function, array, or structure;

Now all of these restrictions are to some degree defensible.
For example: assigning, passing, or otherwise
manipulating functions is plain impossible in
any sort of generality, since it
requires a distinction between function constants and
variables which is not expressible.

Certain restrictions can, at least in theory,
be lifted.
The most important example is the case of a function
which returns a structure.
As I have indicated from the earliest days of C,
I always had in the back of my mind the desirability
of assigning, passing, and returning structures.
Assuming this to have been done, the restrictions
are then

	A structure may not contain a function;
	An array may not consist of functions;
	A function may not return a function or array.

OK. Now suppose we make the rule:

	A member-of-structure, or an array,
	which consists of functions is understood to
	be a pointer to the function.

Now the restrictions are

	A function may not return an array

which is equally easily disposed of by
making the rule

	a function which returns an array is understood to
	return a pointer to the base of the array.

Now there are no restrictions on what can be said in declarations.

Nevertheless:
although the situation may perhaps be clarified in a
psychological sense, nothing is really changed.
In particular, in place of the rule

	A function cannot return a function

we have to state that

	A function which is declared to return a function
	is understood to return a pointer to the
	function.

and perhaps more important, the compiler has to implement
the "is understood to."

I guess the point of this discussion is that although
some of the restrictions on declarations are basically
arbitrary, others are not, and will require some sort
of work by the implementor even in the best of
worlds.

Notice that this discussion is totally independent of
any syntax of parsing method. Beyond any LALR(1)
or any other parsing scheme,
there are fundamental questions in the declaration
"x is a {pointer,array,function,structure}{to,of,returning,containing}
things of type {...}.
Any compiler organization which fails to handle
psychologically acceptable resolutions of these
fundamental semantic questions has a basic
weakness.
