We present a generalisation of first-order unification to the practically important case of equations between terms involving binding operations. A substitution of terms for variables solves such an equation if it makes the equated terms #-equivalent, i.e. equal up to renaming bound names. For the applications we have in mind, we must consider the simple, textual form of substitution in which names occurring in terms may be captured within the scope of binders upon substitution. We are able to take a `nominal' approach to binding in which bound entities are explicitly named (rather than using nameless, de Bruijn-style representations) and yet get a version of this form of substitution that respects #-equivalence and possesses good algorithmic properties. We achieve this by adapting an existing idea and introducing a key new idea. The existing idea is terms involving explicit substitutions of names for names, except that here we only use explicit permutations (bijective substitutions). The key new idea is that the unification algorithm should solve not only equational problems, but also problems about the freshness of names for terms. There is a simple generalisation of the classical first-order unification algorithm to this setting which retains the latter's pleasant properties: unification problems involving #-equivalence and freshness are decidable; and solvable problems possess most general solutions.

This paper proposes N , a compact extension of the -calculus to model dynamic binding, where variables are labelled by names, and where arguments are passed to functions along named channels. The resulting formalism preserves familiar properties of the -calculus, has a Curry-style type inference system, and has a formal notion of compatibility for reasoning about extensible environments. It can encode record and record extensions, as well as first-class contexts with context-filling operations, and therefore provides a basic framework for expressing a wide range of name-based coordination mechanisms. An experimental functional language based on N illustrates the exploitation of dynamic binding in programming language design. 1 Introduction Computer systems are required to be increasingly "open" --- able to dynamically interact with other, possibly unknown or weakly specified systems, and able to coordinate together a global computation. In order to follow this evolution, computational models pay ever increasing attention to notions such as concurrency and distribution. However, open systems also often depend on another concept, more or less orthogonal to the previous ones, and which seems to have been less investigated in theoretical studies: dynamic binding.

. We introduce a simply typed -calculus " which has both contexts and environments as first-class values. In ", holes in contexts are represented by ordinary variables of appropriate types and hole filling is represented by the functional application together with a new abstraction mechanism which takes care of packing and unpacking of the term which is used to fill in the holes of the context. " is a conservative extension of the simply typed fi-calculus, enjoys subject reduction property, is confluent and strongly normalizing. The traditional method of defining substitution does not work for our calculus. So, we also introduce a new method of defining substitution. Although we introduce the new definition of substitution out of necessity, the new definition turns out to be conceptually simpler than the traditional definition of substitution. 1 Introduction Informally speaking, a context (in -calculus) is a -term with some holes in it. For example, writing [ ] for a hole, y: [ ] is a...

This paper considers some theoretical and practical issues concerning the use of linear logic as a logical foundation of functional programming languages such as Haskell and SML. First I give an operational theory for a linear PCF: the (typed) linear - calculus extended with booleans, conditional and non-termination. An operational semantics is given which corresponds in a precise way to the process of fi-reduction which originates from proof theory. Using this operational semantics I define notions of observational equivalence (sometimes called contextual equivalence). Surprisingly, the linearity of the language forces a reworking of the traditional notion of a context (the details are given in an appendix). A co-inductively defined notion, applicative bisimularity, is developed and compared with observational equivalence using a variant of Howe's method. Interestingly the equivalence of these two notions is greatly complicated by the linearity of the language. These equivalences ar...

this paper, we address the problem of names and name capture on its own by designing, through the use of three operators, a complete and consistent mechanism of name capture for a declarative framework. We perceive expressions with free names as incomplete expressions which will be dynamically completed by a name capture mechanism. The formalism allows the denition of rst-class environments (which can be the result of a computation). We apply this mechanism to model distributed incremental program construction and to dene an object oriented programming style in a declarative language

Abstract not found

Most programming languages adopt static binding, but for distributed programming an exclusive reliance on static binding is too restrictive: dynamic binding is required in various guises. Typically it is provided only by ad-hoc mechanisms that lack clean semantics.