Foundations for structured programming with GADTs

Recently there has been a great deal of interest in higher-order syntax which seeks to extend standard initial algebra semantics to cover languages with variable binding. The canonical example studied in the literature is that of the untyped ?-calculus which is handled as an instance of the general theory of binding algebras, cf. Fiore et al. [13]. Another important syntactic construction is that of explicit substitutions which are used to model local definitions and to implement reduction in the ?-calculus. The syntax of a language with explicit substitutions does not form a binding algebra as an explicit substitution may bind an arbitrary number of variables. Thus explicit substitutions are a natural test case for the further development of the theory and applications of syntax with variable binding. This paper shows that a language containing explicit substitutions and a first-order signature ? is naturally modelled as the initial algebra of the Id + F ??_ +_ ? _ endofunctor. We derive a similar formula for adding explicit substitutions to the untyped ?-calculus and then show these initial algebras provide useful datatypes for manipulating abstract syntax by implementing two reduction machines. We also comment on the apparent lack of modularity in syntax with variable binding as compared to first-order languages.

Three versions of the lambda calculus are discussed: typed lambda calculus, untyped lambda calculus, and polymorphically typed lambda calculus. It is shown that the syntax for these calculi can be described as initial algebras for suitable endofunctors. Models of the first two calculi are described as in [Lambek and Scott 1985] and the Per model of the third is recalled. Algebraic types are described in terms of sketches. A main contribution of the paper is the internalization of the theory of sketches in the category Per. Sketches themselves, models of sketches, categories of models of sketches and the category of all models of all sketches can all be realized in this setting. Next, dinatural transformations are reviewed in the context of the category Per and the relation between certain end formulas and initial algebras for finite signatures is discussed. The point of the theory of algebraic semantics in Per is to provide a setting for thinking about algebraic types and algebraic operations in conjunction with logical types and polymorphic operations. Two specific examples are discussed and a general principle for combining algebraic and polymorphic operations is proposed.KeywordsNatural TransformationCategory TheoryLogical TypeDenotational SemanticGraph ObjectThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

This paper extends the fibrational approach to induction and coinduction pioneered by Hermida and Jacobs, and developed by the current authors, in two key directions. First, we present a sound coinduction rule for any data type arising as the final coalgebra of a functor, thus relaxing Hermida and Jacobs' restriction to polynomial data types. For this we introduce the notion of a quotient category with equality (QCE), which both abstracts the standard notion of a fibration of relations constructed from a given fibration, and plays a role in the theory of coinduction dual to that of a comprehension category with unit (CCU) in the theory of induction. Second, we show that indexed inductive and coinductive types also admit sound induction and coinduction rules. Indexed data types often arise as initial algebras and final coalgebras of functors on slice categories, so our key technical results give sufficent conditions under which we can construct, from a CCU (QCE) U : e → B, a fibration with base B/I that models indexing by I and is also a CCU (QCE).

The completeness of the algebraic specification methods for computable data types

This paper deals with KRSS (knowledge representation systems) close to frame systems including description logic and object-based systems. The main relation that leads to inferences is subsumption which is usually computed over knowledge descriptions that refer to data types. Although subsumption between knowledge terms is well-defined, its implementation on external data types depends upon the host language which is used for the actual implementation of data types. As a consequence, no KRS is able to integrate a new (external) data type such that its values can be safely involved in subsumption and further inferences. This is the problem addressed in this paper. The solution we propose relies on the design of a polymorphic type system connected to both the Krs and the host language. It is designed so that it can extend the KRS with any type implementation available in the host language (standard atomic types, library, package, etc.). Meanwhile, the values of the new type get safely involved in the Krs reasoning processes. The presented type system prevents the incompleteness of subsumption due to its incomplete processing on external data.

We develop rules for coalgebras in type theory, and give meaning explanations for them. We show that elements of coalgebras are determined by their elimination rules, whereas the introduction rules can be considered as derived. This is in contrast with algebraic data types, for which the opposite is true: elements are determined by their introduction rules, and the elimination rules can be considered as derived. In this sense, the function type from the logical framework is more like a coalgebraic data type, the elements of which are determined by the elimination rule. We illustrate why the simplest form of guarded recursion is nothing but the introduction rule originating from the formulation of coalgebras in category theory. We discuss restrictions needed in order to preserve decidability of equality.

In many applications, such as algebraic data type specifications and equational programming, equations are intended to define a certain standard model, called the "initial model." Reasoning about algebraic data types and equational programs thus requires proof methods for this initial algebra semantics. Such proof methods typically employ some induction scheme, e. g., induction on the structure of terms. We shall discuss an alternative approach—proof by consistency—that can be applied to equational theories that are presented as ground convergent rewrite systems.

specifications of data types have proved to be a powerful tool in the process of software development. Consequently, semantic theories for programs computing on abstractly specified data types have been studied. At least two different types of theories have emerged. Approaches of the first type view programming language constructs, such as assignment or if-then-else, as operators of algebras that contain as a sub-algebra the data types on which the programs compute. The approaches of [ADJ77], [CoN78], [Wan79a], and [BrW80], among others, belong to this class. This enrichment of the base type by the while-program control constructs is, because of aspects of nontermination, not sufficiently complete in the sense of e.g. [Gut75], [ADJ78a], [Wan79b]. Thus the theory of abstract data types has been extended by various concepts, among them partial algebras and homomorphisms or continuous algebras. The second class of approaches is concerned with programs as implementations of abstractly specified data types. Programs are viewed as data type specifications that extend the base type by the objects (variables, functions, types) it computes [ADJ78a], [Ehr79], [EKP80], [Hup80], [Gan81], among others. Then, the semantics of a terminating program is a “persistent” free functor from the base type theory to these objects.

10 - Numeric Data Types

We give two finite axiomatizations of indexed inductive-recursive definitions in intuitionistic type theory. They extend our previous finite axiomatizations of inductive-recursive definitions of sets to indexed families of sets and encompass virtually all definitions of sets which have been used in intuitionistic type theory. The more restricted of the two axiomatization arises naturally by considering indexed inductive-recursive definitions as initial algebras in slice categories, whereas the other admits a more general and convenient form of an introduction rule.The class of indexed inductive-recursive definitions properly contains the class of indexed inductive definitions (so called “inductive families”). Such definitions are ubiquitous when using intuitionistic type theory for formalizing mathematics and program correctness. A side effect of the present paper is to get compact finite axiomatizations of indexed inductive definitions in intuitionistic type theory as special cases.Proper indexed inductive-recursive definitions (those which do not correspond to indexed inductive definitions) are useful in intuitionistic metamathematics, and as an example we formalize Tait-style computability predicates for dependent types. We also show that Palmgren’s prooftheoretically strong construction of higher-order universes is an example of a proper indexed inductive-recursive definition. A third interesting example is provided by Bove and Capretta’s definition of termination predicates for functions defined by nested recursion.Our axiomatizations form a powerful foundation for generic programming with dependent types by introducing a type of codes for indexed inductive-recursive definitions and making it possible to define generic functions by recursion on this type.KeywordsDependent type theoryMartin-Löf Type Theoryinductive definitionsinductive-recursive definitionsinductive familiesinitial algebrasnormalization proofsgeneric programming

We conceive a parametrized data type as a partial functor ϕ: ALG (σ) → ALG (δ), where δ is a signature extending σ and ALG (σ) is the class of minimal σ-algebras which serve as parameters.We focus attention on one particular method of algebraically specifying parametrized data types: finite specifications with conditional equations using auxiliary sorts and functions provided with initial algebra semantics.We introduce the concept of an effective parametrized data type. A satisfactory adequacy result is then obtained: each effective parametrized data type possesses a finite algebraic specification under initial semantics.KeywordsAbstract Data TypeConditional EquationAlgebraic SpecificationInitial AlgebraSpringer LNCSThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

We propose a uniform, category-theoretic account of structural induction for inductively defined data types. The account is based on the understanding of inductively defined data types as initial algebras for certain kind of endofunctors T: \(\mathbb{B} \to \mathbb{B}\)on a bicartesian/distributive category \(\mathbb{B}\). Regarding a predicate logic as a fibration p: \(\mathbb{P} \to \mathbb{B}\)over \(\mathbb{B}\), we consider a logical predicate lifting of T to the total category \(\mathbb{P}\). Then, a predicate is inductive precisely when it carries an algebra structure for such lifted endofunctor. The validity of the induction principle is formulated by requiring that the ‘truth’ predicate functor ⊤: \(\mathbb{B} \to \mathbb{P}\)preserve initial algebras. We then show that when the fibration admits a comprehension principle, analogous to the one in set theory, it satisfies the induction principle. We also consider the appropriate extensions of the above formulation to deal with initiality (and induction) in arbitrary contexts, i.e. the ‘stability’ property of the induction principle.

This paper states the connection between hierarchical construction of equational specifications and completion of equational term rewriting systems. A general inductive completion algorithm is given, which turns out to be a well-suited tool to build up specifications by successive enrichments. Moreover, the same algorithm allows verifying consistency of a specification or proving theorems in its initial algebra without using explicit induction.

Developing programming languages is a difficult task that requires a lot of time, effort, and expertise. Reusable programming language components make this task easier, by allowing language designers to grab off-the-shelf components for common language features. Modern functional programming languages, however, lack support for reuse of definitions, and thus language components defined using algebraic data types and pattern matching functions cannot be reused without modifying or copying existing code. To improve the situation, we introduce CS, a functional meta-language for developing reusable programming language components, that features built-in support for extensible data types and functions, as well as effects and handlers. In CS, we can define language components using algebraic data types and pattern matching functions, such that we can compose language components into larger languages and define new interpretations for existing components without modifying existing definitions.

The seamless integration of relational databases and programming languages remains a major challenge. Mapping rich data types featured in general-purpose programming languages to the relational data model is one aspect of this challenge. We present a novel technique for mapping arbitrary (nonrecursive) algebraic data types to a relational data model, based on previous work on the relational representation of nested tables. Algebraic data types may be freely constructed and deconstructed in queries and may show up in the result type. The number of relational queries generated is small and statically determined by the type of the query. We have implemented the mapping in the Database Supported Haskell (DSH) library.