Data Type Constructors Research Articles

A functional programmer's guide to homotopy type theory

Dependent type theories are functional programming languages with types rich enough to do computer-checked mathematics and software verification. Homotopy type theory is a recent area of work that connects dependent type theory to the mathematical disciplines of homotopy theory and higher-dimensional category theory. From a programming point of view, these connections have revealed that all types in dependent type theory support a certain generic program that had not previously been exploited. Specifically, each type can be equipped with computationally relevant witnesses of equality of elements of that type, and all types support a generic program that transports elements along these equalities. One mechanism for equipping types with non-trivial witnesses of equality is Voevodsky’s univalence axiom, which implies that equality of types themselves is witnessed by type isomorphism. Another is higher inductive types, an extended datatype schema that allows identifications between different datatype constructors. While these new mechanisms were originally formulated as axiomatic extensions of type theory, recent work has investigated their computational meaning, leading to the development of new programming languages that better support them. In this talk, I will illustrate what univalence and higher inductive types mean in programming terms. I will also discuss how studying some related semantic settings can reveal additional structure on types; for example, moving from groupoids (categories where all maps are invertible) to general categories yields an account of coercions instead of equalities. Overall, I hope to convey some of the beauty and richness of these connections between disciplines, which we are just beginning to understand.

A Tool for Testing Data Type Implementations from Maude Algebraic Specifications

This paper presents a tool for testing data types implemented in C++ against formal specifications written in Maude. Maude is a formal specification language based on rewriting logic that allows the specification of abstract data types in a clear and concise manner. Moreover, Maude specifications are executable, which provides two advantages: firstly, we can test our specifications and, secondly, we can obtain the results of the test cases automatically.We focus our test cases on the correctness of the obtained data values, therefore they are generated from the Maude specification based on the data type constructors and the corresponding membership axioms. On the other hand, the observation of the implementation under test is done for each data type through explicit methods defined by the user. The tool is fully integrated in the Eclipse environment and is platform-independent. We have developed an Eclipse plug-in that calls the Maude system to generate the test cases and then translates them into a sequence of C++ instructions. The C++ instructions are compiled and executed, and the results are compared with the results from the specification.The tool is being used during this academic year by the Computer Science students at the Universidad Complutense de Madrid in the data types course. They have tested typical data type implementations, like stacks, lists, and binary search trees, as well as other data types based on them. The experience is being very useful as it allows the students to test their implementations and correct their errors.

An Innovative Teaching Tool for the Verification of Abstract Data Type Implementations from Formal Algebraic Specifications

This paper presents an educational tool for testing abstract data types implemented in C++ against formal algebraic specifications written in Maude, a formal specification language based on rewriting logic that allows the specification of abstract data types in a clear and concise manner. Maude specifications are executable, which provides two advan-tages: firstly, we can test our specifications and, secondly, we can obtain the results of the test cases automatically. We focus our test cases on the correctness of the obtained data values generated from the Maude specification based on the data type constructors and the corresponding membership axioms. The observation of the implementation under test is done for each abstract data type through explicit methods defined by the user. The teaching tool is fully integrated in the Eclipse environment and is platform-independent. We have developed an Eclipse plug-in that calls the Maude system to generate the test cases and translates them into a sequence of C++ instructions. The C++ instructions are compiled and executed, and the results are compared with the results obtained from the formal algebraic specification. This educational tool is being used during this academic year by the Computer Science students in a data types course. They have tested typical abstract data type implementations, like complex numbers, stacks, lists, and binary search trees, as well as other data types based on them.

Functions and Lazy Evaluation in Prolog

There are several proposals for extending Prolog with functional capabilities. The basic idea is to enlarge the language with function definitions that are translated (or expanded) into Prolog predicates, analogously to what is done for Definite Clause Grammars (DCG's). It is easy to perform such a translation for a basic functional extension, but it requires an additional effort to incorporate more sophisticated functional capabilities such as higher order, lambda abstractions and lazy evaluation. In this paper we describe an extension that covers all these features. The main novelty is our treatment of laziness, as it is (optionally) associated to data type constructors instead of functions. We have found this approach very flexible, easy to use and efficient.

Improving the lazy Krivine machine

Krivine presents the $\mathcal {K}$ machine, which produces weak head normal form results. Sestoft introduces several call-by-need variants of the ${\mathcal {K}}$ machine that implement result sharing via pushing update markers on the stack in a way similar to the TIM and the STG machine. When a sequence of consecutive markers appears on the stack, all but the first cause redundant updates. Improvements related to these sequences have dealt with either the consumption of the markers or the removal of the markers once they appear. Here we present an improvement that eliminates the production of marker sequences of length greater than one. This improvement results in the ${\mathcal {C}}$ machine, a more space and time efficient variant of ${\mathcal {K}}$ . We then apply the classic optimization of short-circuiting operand variable dereferences to create the call-by-need ${\mathcal {S}}$ machine. Finally, we combine the two improvements in the ${\mathcal {CS}}$ machine. On our benchmarks this machine uses half the stack space, performs one quarter as many updates, and executes between 27% faster and 17% slower than our ? variant of Sestoft's lazy Krivine machine. More interesting is that on one benchmark ?, ${\mathcal {S}}$ , and ${\mathcal {C}}$ consume unbounded space, but ${\mathcal {CS}}$ consumes constant space. Our comparisons to Sestoft's Mark 2 machine are not exact, however, since we restrict ourselves to unpreprocessed closed lambda terms. Our variant of his machine does no environment trimming, conversion to deBruijn-style variable access, and does not provide basic constants, data type constructors, or the recursive let. (The Y combinator is used instead.)

A constraint-based approach to guarded algebraic data types

We study HMG( X ), an extension of the constraint-based type system HM( X ) with deep pattern matching, polymorphic recursion, and guarded algebraic data types . Guarded algebraic data types subsume the concepts known in the literature as indexed types , guarded recursive datatype constructors , (first-class) phantom types , and equality qualified types , and are closely related to inductive types . Their characteristic property is to allow every branch of a case construct to be typechecked under different assumptions about the type variables in scope. We prove that HMG( X ) is sound and that, provided recursive definitions carry a type annotation, type inference can be reduced to constraint solving. Constraint solving is decidable, at least for some instances of X , but prohibitively expensive. Effective type inference for guarded algebraic data types is left as an issue for future research.

Typed compilation of recursive datatypes

Standard ML employs an opaque (or generative) semantics of datatypes, in which every datatype declaration produces a new type that is different from any other type, including other identically defined datatypes. A natural way of accounting for this is to consider datatypes to be abstract. When this interpretation is applied to type-preserving compilation, however, it has the unfortunate consequence that datatype constructors cannot be inlined, substantially increasing the run-time cost of constructor invocation compared to a traditional compiler. In this paper we examine two approaches to eliminating function call overhead from datatype constructors. First, we consider a transparent interpretation of datatypes that does away with generativity, altering the semantics of SML; and second, we propose an interpretation of datatype constructors as coercions, which have no run-time effect or cost and faithfully implement SML semantics.

Guarded recursive datatype constructors

We introduce a notion of guarded recursive (g.r.) datatype constructors, generalizing the notion of recursive datatypes in functional programming languages such as ML and Haskell. We address both theoretical and practical issues resulted from this generalization. On one hand, we design a type system to formalize the notion of g.r. datatype constructors and then prove the soundness of the type system. On the other hand, we present some significant applications (e.g., implementing objects, implementing staged computation, etc.) of g.r. datatype constructors, arguing that g.r. datatype constructors can have far-reaching consequences in programming. The main contribution of the paper lies in the recognition and then the formalization of a programming notion that is of both theoretical interest and practical use.

Observational logic, constructor-based logic, and their duality

Observability and reachability are important concepts for formal software development. While observability concepts are used to specify the required observable behavior of a program or system, reachability concepts are used to describe the underlying data in terms of datatype constructors. In this paper we first reconsider the observational logic institution which provides a logical framework for dealing with observability. Then we develop in a completely analogous way the constructor-based logic institution which formalizes a novel treatment of reachability. Both institutions are tailored to capture the semantically correct realizations of a specification from either the observational or the reachability point of view. We show that there is a methodological and even formal duality between both frameworks. In particular, we establish a correspondence between observer operations and datatype constructors, observational and constructor-based algebras, fully abstract and reachable algebras, and observational and inductive consequences of specifications. The formal duality between the observability and reachability concepts is established in a category-theoretic setting.

Deriving a lazy abstract machine

We derive a simple abstract machine for lazy evaluation of the lambda calculus, starting from Launchbury's natural semantics. Lazy evaluation here means non-strict evaluation with sharing of argument evaluation, i.e. call-by-need. The machine we derive is a lazy version of Krivine's abstract machine, which was originally designed for call-by-name evaluation. We extend it with datatype constructors and base values, so the final machine implements all dynamic aspects of a lazy functional language.

Comparison of Functional and Predicative Query Paradigms

In the last decade many extensions of the relational model were proposed, and basic properties of the relational model were investigated in their contexts. In particular, the equivalence of calculus and algebra, and the relative expressive power of other related languages were explored. This paper investigates this subject in a general framework, independently of any specific data type constructors that may exist in specific models, with the goal of making explicit the conditions that enable translation between query languages. The framework is based on a combination the well-founded approach of deductive programs and the initial algebra approach of algebraic specifications. The latter does not support negation (i.e., disequations); hence our combination contributes to the theory of algebraic specifications. Given the framework, we present the predicative and functional approaches to database description and querying. The first leads to the calculus and deductive approaches, the second to several algebras and, also, to generalizations that allow restricted definition by equations. We extend the notions of domain independence to our framework. We then present various sufficient conditions for the calculus and (some) algebra to be equivalent. We also compare the expressive power of algebras and more general languages to several deductive languages, under stratified and well-founded semantics. Finally, we define safety conditions and prove similar results for safe versions of the languages.

First-class data-type representations in SCHEMEXEROX

In most programming language implementations, the compiler has detailed knowledge of the representations of and operations on primitive data typed and data-type constructors. In SCHEMEXEROX, this knowledge is almost entirely external to the compiler, in ordinary, procedural user code. The primitive representations and operations are embodied in first-class “representation types” that are constructed and implemented in an abstract and high-level fashion. Despite this abstractness, a few generally-useful optimizing transformations are sufficient to allow the SCHEMEXEROX compiler to generate efficient code for the primitive operations, essentially as good as could be achieved using more contorted, traditional techniques.

Semantic database modeling: survey, applications, and research issues

Most common database management systems represent information in a simple record-based format. Semantic modeling provides richer data structuring capabilities for database applications. In particular, research in this area has articulated a number of constructs that provide mechanisms for representing structurally complex interrelations among data typically arising in commercial applications. In general terms, semantic modeling complements work on knowledge representation (in artificial intelligence) and on the new generation of database models based on the object-oriented paradigm of programming languages.This paper presents an in-depth discussion of semantic data modeling. It reviews the philosophical motivations of semantic models, including the need for high-level modeling abstractions and the reduction of semantic overloading of data type constructors. It then provides a tutorial introduction to the primary components of semantic models, which are the explicit representation of objects, attributes of and relationships among objects, type constructors for building complex types, ISA relationships, and derived schema components. Next, a survey of the prominent semantic models in the literature is presented. Further, since a broad area of research has developed around semantic modeling, a number of related topics based on these models are discussed, including data languages, graphical interfaces, theoretical investigations, and physical implementation strategies.