[Prev][Next][Index][Thread]

paper available by ftp - Prameterized Interfaces can be Interfaces


Over the last couple of years we have been working on a system for
higher order module parameterization in which parameterized interfaces
can be interfaces (as opposed to most approaches which distinguish
parameterized types from types of parameterized entities).

A paper with our results is now accessible via
anonymous ftp  from the ftp site:
                      santos.doc.ic.ac.uk
in the dirctory:
                      pub/papers/R.Paterson
under the name:
                      HigherOrderParam.dvi
or
                      HigherOrderParam.dvi.gz 
                       (compressed, can be uncompressed with gunzip
                        producing head.dvi)

Ross Paterson, Sophia Drossopoulou

---------------------- ABSTRACT ----------------------

We suggest a new approach to expressing higher-order parameterization
and abstraction for modules.  A module consists of an interface and an
implementation.  Both interfaces and implementations can be
parameterized to any order.  A sub-interface relationship is assumed
for primitive interfaces, and is extended to higher-order interfaces.
Our proposal is conceptually simpler than alternative approaches that
have been pursued, because we use parameterized interfaces as
interfaces for parameterized implementations.  Also, programs written
according to this approach are shorter.  The construction we describe
is applicable as an extension of any language satisfying certain loose
conditions.

We also give the semantics of this system.  Because the system is
conceived as extension of any language which supports strong typing,
the semantics of is also expressed as an extesion of the semantics of
the underlying language.

Furthermore, we introduce a deterministic, terminating algorithm for
checking parameterized modules.  Again, this algorithm is conceived as
an extension of the algorithm for checking modules in the underlying
language.