Opaque Signature Inference for ML

Several languages provide robust module systems for creating software
components.  The module system allows each component to specify which
of its declarations are concrete and which are opaque through an
interface definition.  Opaque interfaces minimize inter-component
dependencies and encourage modular design, but may be impractical
because they hide information that would otherwise be beneficial to
share with related modules.  Since the programmer must specify these
interfaces by hand, he must consider all possible uses of the module.
In large software projects, the module may be used in a myriad of
locations, each with a different requirement for how opaque the module
should be, thus it may be difficult for the programmer to write an
appropriate signature.  In this work, we present a tool for inferring
the most opaque interface for a module given its usage with a specific
program.  Our tool infers module signatures for the O'Caml language,
and we have run it on a small set of examples.  Our results suggest
that this tool provides the programmer with information that is
helpful in determining an appropriate signature for a module,
especially when examining complex type definitions.  This information
is also useful since it shows the programmer what parts of the module
may be safely changed or removed without affecting the rest of the
program.