To save content items to your account,
please confirm that you agree to abide by our usage policies.
If this is the first time you use this feature, you will be asked to authorise Cambridge Core to connect with your account.
Find out more about saving content to .
To save content items to your Kindle, first ensure firstname.lastname@example.org
is added to your Approved Personal Document E-mail List under your Personal Document Settings
on the Manage Your Content and Devices page of your Amazon account. Then enter the ‘name’ part
of your Kindle email address below.
Find out more about saving to your Kindle.
Note you can select to save to either the @free.kindle.com or @kindle.com variations.
‘@free.kindle.com’ emails are free but can only be saved to your device when it is connected to wi-fi.
‘@kindle.com’ emails can be delivered even when you are not connected to wi-fi, but note that service fees apply.
Recursive definitions of predicates are usually interpreted either inductively or coinductively. Recently, a more powerful approach has been proposed, called flexible coinduction, to express a variety of intermediate interpretations, necessary in some cases to get the correct meaning. We provide a detailed formal account of an extension of logic programming supporting flexible coinduction. Syntactically, programs are enriched by coclauses, clauses with a special meaning used to tune the interpretation of predicates. As usual, the declarative semantics can be expressed as a fixed point which, however, is not necessarily the least, nor the greatest one, but is determined by the coclauses. Correspondingly, the operational semantics is a combination of standard SLD resolution and coSLD resolution. We prove that the operational semantics is sound and complete with respect to declarative semantics restricted to finite comodels.
We extend the simply-typed lambda-calculus with a mechanism for dynamic and incremental rebinding of code. Fragments of open code which can be dynamically rebound are values. Differently from standard static binding, which is done on a positional basis, rebinding is done on a nominal basis, that is, free variables in open code are associated with names which do not obey α-equivalence. Moreover, rebinding is incremental, that is, just a subset of names can be rebound, making possible code specialization, and rebinding can even introduce new names. Finally, rebindings, which are associations between names and terms, are first-class values, and can be manipulated by operators such as overriding and renaming. We define a type system in which the type for a rebinding, in addition to specify an association between names and types (similarly to record types), is also annotated. The annotation says whether or not the domain of the rebinding having this type may contain more names than the ones that are specified in the type. We show soundness of the type system.
We extend the simply typed
λ-calculus with unbind and rebind primitive
constructs. That is, a value can be a fragment of open code,
which in order to be used should be explicitly rebound. This
mechanism nicely coexists with standard static binding. The
motivation is to provide an unifying foundation for mechanisms of
dynamic scoping, where the meaning of a name is
determined at runtime, rebinding, such as dynamic updating
of resources and exchange of mobile code, and delegation,
where an alternative action is taken if a binding is missing.
Depending on the application scenario, we consider two
extensions which differ in the way type safety is guaranteed. The
former relies on a combination of static and dynamic type checking.
That is, rebind raises a dynamic error if for some variable
there is no replacing term or it has the wrong type. In the latter,
this error is prevented by a purely static type system, at the price
of more sophisticated types.
We propose a semantic framework for dynamic systems, which, in a sense, extends the well-known algebraic approach for modelling static data structures to the dynamic case. The framework is based on a new mathematical structure, called a d-oid, consisting of a set of instant structures and a set of dynamic operations. An instant structure is a static structure, e.g. an algebra; a dynamic operation is a transformation of instant structures with an associated point to point map, which allows us to keep track of the transformations of single objects and thus is called a tracking map. By an appropriate notion of morphism, the d-oids over a dynamic signature constitute a category.
It is shown that d-oids can model object systems and support an abstract notion of possibly unique object identity; moreover, for a d-oid satisfying an identity preserving condition, there exists an essentially equivalent d-oid where the elements of instant structures are just names.
We present a simple module calculus where selection and execution of a component is possible on open modules, that is, modules that still need to import some external definitions. Hence, it provides a kernel model for a computational paradigm in which standard execution (that is, execution of a single computation described by a fragment of code) can be interleaved with operations at the meta-level, which can manipulate in various ways the context in which this computation takes place. Formally, this is achieved by introducing configurations as basic terms. These are, roughly speaking, pairs consisting of an (open, mutually recursive) collection of named components and a term representing a program running in the context of these components. Configurations can be manipulated by classical module/fragment operators, hence reduction steps can be either execution steps of the program or steps that perform module operations (called reconfiguration steps).
Since configurations combine the features of lambda abstractions (first-class functions), records, environments with mutually recursive definitions and modules, the calculus extends and integrates both traditional module calculi and recursive lambda calculi. We state confluence of the calculus, and propose different ways to prevent errors arising from the lack of some required component, either by a purely static type system or by a combination of static and run-time checks. Moreover, we define a call-by-need strategy that performs module simplification only when needed and only once, leading to a generalisation of call-by-need lambda calculi that includes module features. We prove the soundness and completeness of this strategy using an approach based on information content, which also allows us to preserve confluence, even when local substitution rules are added to the calculus.
Mixins are modules that may contain deferred components, that is, components not defined
in the module itself; moreover, in contrast to parameterised modules (like ML functors),
they can be mutually dependent and allow their definitions to be overridden. In a preceding
paper we defined a syntax and denotational semantics of a kernel language of mixin
modules. Here, we take instead an axiomatic approach, giving a set of algebraic laws
expressing the expected properties of a small set of primitive operators on mixins.
Interpreting axioms as rewriting rules, we get a reduction semantics for the language and
prove the existence of normal forms. Moreover, we show that the model defined in the
earlier paper satisfies the given axiomatisation.
We present CMS, a simple and powerful calculus of modules supporting mutual recursion
and higher order features, which can be instantiated over an arbitrary core calculus satisfying
standard assumptions. The calculus allows expression of a large variety of existing mechanisms
for combining software components, including parameterized modules similar to ML
functors, extension with overriding as in object-oriented programming, mixin modules and
extra-linguistic mechanisms like those provided by a linker. Hence CMS can be used as a
paradigmatic calculus for modular languages, in the same spirit the lambda calculus is used
for functional programming. We first present an untyped version of the calculus and then a
type system; we prove confluence, progress, and subject reduction properties. Then, we define
a derived calculus of mixin modules directly in terms of CMS and show how to encode other
primitive calculi into CMS (the lambda calculus and the Abadi-Cardelli object calculus).
Finally, we consider the problem of introducing a subtype relation for module types.
Mixins are modules in which some components are deferred,
is, their definition has to
be provided by another module. Moreover, in contrast to parameterized modules
functors), mixin modules can be mutually dependent and their composition
redefinition of components (overriding). In this
paper, we present a formal model of mixins
and their basic composition operators. These operators can be viewed as
a kernel language
with clean semantics in which one can express more complex operators of
languages, including variants of inheritance in object-oriented programming.
model is given in an ‘institution independent’ way,
that is, it is parameterized by the
semantic framework modelling the underlying core language.
Email your librarian or administrator to recommend adding this to your organisation's collection.