On the implementation of abstract data types by programming language constructs

AbstractImplementations of abstract data types are defined via enrichments of a target type. We propose to use an extended typed λ-calculus for enrichments in order to meet the conceptual requirement that an implementation has to bring us closer to a (functional) program. Composability of implementations is investigated, the main result being that composition of correct implementations is correct if terminating programs are implemented by terminating programs. Moreover, we provide syntactical criteria to guarantee correctness of composition. The proof is based on strong normalization and Church-Rosser results of the extended λ-calculus which seem to be of interest in their own right

Parametric Compositional Data Types

In previous work we have illustrated the benefits that compositional data types (CDTs) offer for implementing languages and in general for dealing with abstract syntax trees (ASTs). Based on Swierstra's data types \'a la carte, CDTs are implemented as a Haskell library that enables the definition of recursive data types and functions on them in a modular and extendable fashion. Although CDTs provide a powerful tool for analysing and manipulating ASTs, they lack a convenient representation of variable binders. In this paper we remedy this deficiency by combining the framework of CDTs with Chlipala's parametric higher-order abstract syntax (PHOAS). We show how a generalisation from functors to difunctors enables us to capture PHOAS while still maintaining the features of the original implementation of CDTs, in particular its modularity. Unlike previous approaches, we avoid so-called exotic terms without resorting to abstract types: this is crucial when we want to perform transformations on CDTs that inspect the recursively computed CDTs, e.g. constant folding.Comment: In Proceedings MSFP 2012, arXiv:1202.240

JMatch: Java plus Pattern Matching

The JMatch language extends Java with \emph{iterable abstract pattern matching}, pattern matching that is compatible with the data abstraction features of Java and makes iteration abstractions convenient. JMatch has ML-style deep pattern matching, but patterns can be abstract; they are not tied to algebraic data constructors. A single JMatch method may be used in several modes; modes may share a single implementation as a boolean formula. Modal abstraction simplifies specification and implementation of abstract data types. This paper describes the JMatch language and its implementation. (updated April 20, 2005)

Implementation of abstract data types in programming language C++

Tema ovog završnog rada je „Implementacija apstraktnih tipova podataka u programskom jeziku C++“. Detaljno su opisani apstraktni tipovi podataka i operacije koje se izvršavaju nad njima. Oni nisu ugrađeni u programskom jeziku već ih programer sam implementira, a implementacije se razlikuju po strukturi i algoritmima za izvršavanje pojedine operacije, tako svaki apstraktni tip podatka može imati više implementacija. Dijele se na četiri vrste, a to su linearni, hijerarhijski, dvodimenzionalni nehijerarhijski i skupovni. U programskom jeziku C++ će biti implementirani svi navedeni apstraktni tipovi te na kraju svakog poglavlja određena složenost svake funkcije.In this bachelor's thesis „Implementation of abstract data types in C++ programming language“ the abstract data types and operations that are executed over them are described in detail. They are not embedded in the programming language, but are implemented by the developer, and implementations vary by structure and algorithms to execute an operation, so any abstract data type can have multiple implementations. They are divided into four types, linear, hierarchical, two-dimensional non-hierarchical and sets. In the C ++ programming language, all of the above mentioned types will be implemented, and at the end of each chapter will determine the complexity of each function

Implementation of abstract data types in programming language C++

Tema ovog završnog rada je „Implementacija apstraktnih tipova podataka u programskom jeziku C++“. Detaljno su opisani apstraktni tipovi podataka i operacije koje se izvršavaju nad njima. Oni nisu ugrađeni u programskom jeziku već ih programer sam implementira, a implementacije se razlikuju po strukturi i algoritmima za izvršavanje pojedine operacije, tako svaki apstraktni tip podatka može imati više implementacija. Dijele se na četiri vrste, a to su linearni, hijerarhijski, dvodimenzionalni nehijerarhijski i skupovni. U programskom jeziku C++ će biti implementirani svi navedeni apstraktni tipovi te na kraju svakog poglavlja određena složenost svake funkcije.In this bachelor's thesis „Implementation of abstract data types in C++ programming language“ the abstract data types and operations that are executed over them are described in detail. They are not embedded in the programming language, but are implemented by the developer, and implementations vary by structure and algorithms to execute an operation, so any abstract data type can have multiple implementations. They are divided into four types, linear, hierarchical, two-dimensional non-hierarchical and sets. In the C ++ programming language, all of the above mentioned types will be implemented, and at the end of each chapter will determine the complexity of each function

Automatic Verification of Erlang-Style Concurrency

This paper presents an approach to verify safety properties of Erlang-style, higher-order concurrent programs automatically. Inspired by Core Erlang, we introduce Lambda-Actor, a prototypical functional language with pattern-matching algebraic data types, augmented with process creation and asynchronous message-passing primitives. We formalise an abstract model of Lambda-Actor programs called Actor Communicating System (ACS) which has a natural interpretation as a vector addition system, for which some verification problems are decidable. We give a parametric abstract interpretation framework for Lambda-Actor and use it to build a polytime computable, flow-based, abstract semantics of Lambda-Actor programs, which we then use to bootstrap the ACS construction, thus deriving a more accurate abstract model of the input program. We have constructed Soter, a tool implementation of the verification method, thereby obtaining the first fully-automatic, infinite-state model checker for a core fragment of Erlang. We find that in practice our abstraction technique is accurate enough to verify an interesting range of safety properties. Though the ACS coverability problem is Expspace-complete, Soter can analyse these verification problems surprisingly efficiently.Comment: 12 pages plus appendix, 4 figures, 1 table. The tool is available at http://mjolnir.cs.ox.ac.uk/soter

An extended relational data base management system for engineering design

At present, the use of the relational model in the engineering design support domain is restricted due to the following: lack of ability to handle complex objects, no support for Abstract Data Types, inappropriate concurrency control for long transactions, no support for versioning and update propagation, poor efficiency, and insufficient design rule checking and consistency contraints enforcement. A simple relational database management system is designed and implemented under the UNIX operating system to incorporate two major extensions: support of user-defined Abstract Data Types and operators, and built-in Design Data Versioning. The design, implementation, and possible extensions to these new facilities are described

Extending iStar2.0 metamodel to define data structures

iStar2.0 provides a recommendation for the core constructs defined in the i* language, which are articulated around a metamodel. When applying iStar2.0 to a particular domain, it can be necessary to extend this metamodel in order to represent more specialized concepts. One of these domains is that of data structures, as implementation of abstract data types. In this paper, we build upon previous work on using i* to describe data structures from an intentional point of view, by introducing new constructs in iStar2.0 and adding them to the iStar2.0 metamodel. We illustrate the approach using some well-known abstract data types (sequences, functions, …) and the data structures implementing them (linked lists, heaps, hash tables, …).Peer ReviewedPostprint (published version

On the theory of specification, implementation, and parametrization of abstract data types

ABSTRACT. In the framework of a category spec of equational speoficatlons of abstract data types, tmplementations are defined to be certain pairs of morphlsms with a common target Th~s concept covers, among others, arbitrary recurslon schemes for defining the derived operations It is shown that for given single steps of a multilevel tmplementatlon, there is always a multtlevel tmplementatlon composed of these steps, but there ts no effective construction of th~s overall implementauon Some suggestions are gtven for practtcal composition of tmplementat~ons Utdlzmg pushouts Parametric specifications and parameter assignments are defined to be spectal morphlsms in spec, and parameter substitution ~s made precise by means of pushouts Since actual parameters can agam be parametrtc, parameter subsututton can be tterated. Thts tterauon ts shown to be assoctatwe Whtle the subject is being treated on a syntactical level in terms of speclfieauons, the imtlal algebra approach ts adopted as providing an appropriate semantics for spec~ficauons, and the effects of the present concepts and results on the initial algebras are studie