_P_l_a_c_e_h_o_l_d_e_r_ _t_y_p_e_s

A placeholder type has  no  values  belonging  to  it  (apart  from  the
undefined  value,  undef, which is a member of every type).  Placeholder
types are useful in program development.  Placeholder types are declared
as follows:

	widget :: _t_y_p_e

declares  `widget'  to be a `placeholder type'.  This enables us to give
type specifications involving widget, for example

	f :: num->widget->widget
	g :: widget->widget

The sole purpose of this setup is (as the  name  suggests)  to  `hold  a
place'   during  program  development.   At  a  later  stage  the  above
declaration of widget as a placeholder type will be removed in favour of
some specific type definition for widget (using ::=, _a_b_s_t_y_p_e or ==).

Placeholder typenames can have any arity, eg we could have said:
	widget * ** :: _t_y_p_e
This creates a family of placeholder types, such as  `widget  num  bool'
and  so  on.   They  are all `empty' (meaning they have no values except
undef).  The general form of this kind of specification is
	tform-list :: _t_y_p_e
where `tform' consists of a typename followed by zero  or  more  generic
type variables (and it is permitted to declare several placeholder types
simultaneously, separated by commas, whence `tform-list').

The philosophy behind allowing placeholder types is that when developing
a  complex piece of software it is often helpful to declare the types of
a group of functions and data structures, and have this type information
checked for consistency, before taking representation decisions, such as
whether a given type is going to be abstract or algebraic etc.

A placeholder type may be considered as equivalent to an algebraic  type
with no constructors.

