DOCSLIB.ORG

Parametric Polymorphism for Software Component Architectures

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

Parametric Polymorphism for Software Component Architectures Cosmin E. Oancea Stephen M. Watt Computer Science Department Computer Science Department The University of Western Ontario The University of Western Ontario London, Ontario, Canada London, Ontario, Canada [email protected] [email protected] ABSTRACT 1. INTRODUCTION Parametric polymorphism has become a common feature This paper examines what is required to have multi-lang- of mainstream programming languages, but software com- uage parameterized components interoperate and how to ac- ponent architectures have lagged behind and do not sup- cess existing generic libraries across language boundaries. port it. We examine the problem of providing paramet- We propose a common model for parametric polymorphism ric polymorphism with components combined from different that accommodates a representative range of different ob- programming languages. We have investigated how to re- ject semantics and binding times from various languages and solve different binding times and parametrization semantics use it to design a “generic” software component architecture in a range of representative languages and have identified extension that can be applied on top of most component ar- a common ground that can be suitably mapped to differ- chitectures in use today. ent language bindings. We present a generic component Software component architectures provide mechanisms for architecture extension that provides support for parameter- software modules to be developed independently, using dif- ized components and that can be easily adapted to work on ferent programming languages, and for these components to top of various software component architectures in use to- be combined in various configurations to construct appli- day (e.g., corba, dcom, jni). We have implemented and cations. To provide the richest environment, these architec- tested this architecture on top of corba. We also present tures have historically attempted to capture the intersection Generic Interface Definition Language (gidl), an extension of features of the programming languages for which they to corba-idl supporting generic types and we describe lan- have bindings. Common programming practice has evolved guage bindings for C++, Java and Aldor. We explain our a great deal, however, since the component architectures implementation of gidl, consisting of a gidl to idl com- in common use today were established. Notably, paramet- piler and tools for generating linkage code under the lan- ric polymorphism has evolved from a beautiful property of guage bindings. We demonstrate how this architecture can research-oriented programming languages to become a stan- be used to access C++’s stl and Aldor’s BasicMath libraries dard feature of languages used in mainstream applications. in a multi-language environment and discuss our mappings The concept of multi-language, multi-platform components in the context of automatic library interface generation. must similarly evolve if we wish our components to enjoy the benefits of parametric polymorphism. Categories and Subject Descriptors Parametric polymorphism is one mechanism by which pro- D.1.5 [Programming Techniques]: Object-oriented Pro- gramming languages may provide support for generic pro- gramming; D.2.2 [Software Engineering]: Modules and gramming. By associating all behavior of parameter values interfaces, Software libraries; D.2.11 [Software Engineer- with the types of the parameters, it becomes possible to ing]: Languages—interconnection; D.2.12 [Software En- write generic programs. These types can either be stated gineering]: Interoperability explicitly as parameters to a module, or inferred, depend- ing on the setting. Explicit parametric polymorphism has General Terms become more widely used, in practice, and has certain the- Languages, Design oretical benefits, including termination of type inference in some higher order languages [18]. Parametric polymorphism Keywords increases the flexibility, re-usability, and expressive power of Antiunification, Generics, Parametric Polymorphism, the programming environment, avoids the need for down- Software Component Architecture, Templates casting and allows a compiler to find more programming errors. There are quite a few popular programming lan- guages with support for parametric polymorphism, albeit with differing semantics. We review a few, to give an idea of Permission to make digital or hard copies of all or part of this work for the range a general facility must be able to map onto. Our personal or classroom use is granted without fee provided that copies are conclusion is that a mechanism to combine modules in differ- not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to ent programming languages must be able to accommodate republish, to post on servers or to redistribute to lists, requires prior specific both compile-time and run-time instantiation of modules permission and/or a fee. and both qualified and unqualified type variables. (Here, OOPSLA’05, October 16–20, 2005, San Diego, California, USA. and throughout the paper, we use the term qualified as a Copyright 2005 ACM 1-59593-031-0/05/0010 ...$5.00. synonym for bounded quantification [2].) 147 Our work was inspired by an early experiment [4], briefly 2. BACKGROUND AND MOTIVATION presented in Section 2, where two languages with differ- This section lays out the background and context for our ent parametric polymorphism semantics and different bind- work. We first explain the original motivation and the design ing time models were made to work together. The experi- point we desire to satisfy. We then lay out the context of the ment linked C++, with compile time template instantiation, work, summarizing the parametric polymorphism semantics and Aldor, with run time higher-order functions producing of a few languages to give an idea of the range a general dependent types. This experiment motivated the present, facility must be able to map on to. Finally, we briefly re- more general, approach. view several software component architectures in use today We have developed an extension to corba’s Interface Def- to understand how they can be extended with parametric inition Language (idl) to support parameterized interfaces. polymorphism. We have dubbed this extended specification language Generic IDL, or gidl for short. In this paper we present our im- 2.1 Motivation and Design Point plementation of , which consists of a to com- gidl gidl idl The initial motivation for our work arose building a link- piler and code generators implementing C++, Java and Aldor age between Aldor and C++ in the context of a European bindings. encapsulates a common model for generics gidl project for symbolic-numeric computation. The two main and provides efficient implementation under a wide spec- background items brought into the project were (1) a com- trum of requirements for specific semantics and binding times plex, heavily template-based C++ library, PoSSo, for the ex- of the supported languages. Our component architecture act solution of multivariate polynomial equations over var- extension does not assume a homogeneous environment. Its ious coefficient fields, and (2) an optimizing compiler for design, which constitutes in our view a novel application of a higher-order programming language, Aldor, used in com- the type erasure technique to implement generics in a het- puter algebra. One of the specific objectives of the project erogeneous environment, allows it to be easily adapted to was to allow Aldor programs to make use of the PoSSo li- work on top of most software component architectures in brary. From this very practical problem arose the interesting use today: is just our working study case. corba challenge to make two languages with very different binding To test the effectiveness of our model for generics, we time models and parametric polymorphism semantics work have investigated how to use gidl as a vehicle to access two together (C++ with compile-time template class instantia- generic libraries beyond their original language boundaries. tion and Aldor with run-time higher-order functions pro- The first library experiment implements a server incorporat- ducing dependent types). A detailed account of this work is ing part of the C++ Standard Template Library ( ) func- stl given elsewhere [4, 5]. This experiment established that we tionality. We have not re-written the stl: our implementa- could overcome the C++/ Aldor semantic gap and motivated tion uses the as a black box, wrapping it in a manner stl our search for a systematic solution for parametric polymor- that can easily be automated. We find that is perhaps gidl phism for components, encompassing more languages in a more suitable than C++ to express the “orthogonality” stl simpler way. semantics. Our specification is self-explanatory and self- Since the semantics of generics are different in various contained, in the sense that it does not need free language programming languages, we have been forced to identify a annotation to explain type safety constraints. The second common ground that can be suitably mapped to these lan- library experiment explores the high-level conceptual ideas guages efficiently. gidl supports mappings to Java, C++ and involved in mapping the semantics of the Aldor BasicMath Aldor, thus handling a wide spectrum of parametric poly- library to a specification. We see that Aldor’s func- gidl morphism and binding time semantics. We are not
Recommended publications
  • Axiom / Fricas

    Axiom / Fricas

    Axiom / FriCAS Christoph Koutschan Research Institute for Symbolic Computation Johannes Kepler Universit¨atLinz, Austria Computer Algebra Systems 15.11.2010 Master's Thesis: The ISAC project • initiative at Graz University of Technology • Institute for Software Technology • Institute for Information Systems and Computer Media • experimental software assembling open source components with as little glue code as possible • feasibility study for a novel kind of transparent single-stepping software for applied mathematics • experimenting with concepts and technologies from • computer mathematics (theorem proving, symbolic computation, model based reasoning, etc.) • e-learning (knowledge space theory, usability engineering, computer-supported collaboration, etc.) • The development employs academic expertise from several disciplines. The challenge for research is interdisciplinary cooperation. Rewriting, a basic CAS technique This technique is used in simplification, equation solving, and many other CAS functions, and it is intuitively comprehensible. This would make rewriting useful for educational systems|if one copes with the problem, that even elementary simplifications involve hundreds of rewrites. As an example see: http://www.ist.tugraz.at/projects/isac/www/content/ publications.html#DA-M02-main \Reverse rewriting" for comprehensible justification Many CAS functions can not be done by rewriting, for instance cancelling multivariate polynomials, factoring or integration. However, respective inverse problems can be done by rewriting and produce human readable derivations. As an example see: http://www.ist.tugraz.at/projects/isac/www/content/ publications.html#GGTs-von-Polynomen Equation solving made transparent Re-engineering equation solvers in \transparent single-stepping systems" leads to types of equations, arranged in a tree. ISAC's tree of equations are to be compared with what is produced by tracing facilities of Mathematica and/or Maple.
  • Design and Implementation of Generics for the .NET Common Language Runtime

    Design and Implementation of Generics for the .NET Common Language Runtime

    Design and Implementation of Generics for the .NET Common Language Runtime Andrew Kennedy Don Syme Microsoft Research, Cambridge, U.K. fakeÒÒ¸d×ÝÑeg@ÑicÖÓ×ÓfغcÓÑ Abstract cally through an interface definition language, or IDL) that is nec- essary for language interoperation. The Microsoft .NET Common Language Runtime provides a This paper describes the design and implementation of support shared type system, intermediate language and dynamic execution for parametric polymorphism in the CLR. In its initial release, the environment for the implementation and inter-operation of multiple CLR has no support for polymorphism, an omission shared by the source languages. In this paper we extend it with direct support for JVM. Of course, it is always possible to “compile away” polymor- parametric polymorphism (also known as generics), describing the phism by translation, as has been demonstrated in a number of ex- design through examples written in an extended version of the C# tensions to Java [14, 4, 6, 13, 2, 16] that require no change to the programming language, and explaining aspects of implementation JVM, and in compilers for polymorphic languages that target the by reference to a prototype extension to the runtime. JVM or CLR (MLj [3], Haskell, Eiffel, Mercury). However, such Our design is very expressive, supporting parameterized types, systems inevitably suffer drawbacks of some kind, whether through polymorphic static, instance and virtual methods, “F-bounded” source language restrictions (disallowing primitive type instanti- type parameters, instantiation at pointer and value types, polymor- ations to enable a simple erasure-based translation, as in GJ and phic recursion, and exact run-time types.
  • Parametric Polymorphism Parametric Polymorphism

    Parametric Polymorphism Parametric Polymorphism

    Parametric Polymorphism Parametric Polymorphism • is a way to make a language more expressive, while still maintaining full static type-safety (every Haskell expression has a type, and types are all checked at compile-time; programs with type errors will not even compile) • using parametric polymorphism, a function or a data type can be written generically so that it can handle values identically without depending on their type • such functions and data types are called generic functions and generic datatypes Polymorphism in Haskell • Two kinds of polymorphism in Haskell – parametric and ad hoc (coming later!) • Both kinds involve type variables, standing for arbitrary types. • Easy to spot because they start with lower case letters • Usually we just use one letter on its own, e.g. a, b, c • When we use a polymorphic function we will usually do so at a specific type, called an instance. The process is called instantiation. Identity function Consider the identity function: id x = x Prelude> :t id id :: a -> a It does not do anything with the input other than returning it, therefore it places no constraints on the input's type. Prelude> :t id id :: a -> a Prelude> id 3 3 Prelude> id "hello" "hello" Prelude> id 'c' 'c' Polymorphic datatypes • The identity function is the simplest possible polymorphic function but not very interesting • Most useful polymorphic functions involve polymorphic types • Notation – write the name(s) of the type variable(s) used to the left of the = symbol Maybe data Maybe a = Nothing | Just a • a is the type variable • When we instantiate a to something, e.g.
  • CSE 307: Principles of Programming Languages Classes and Inheritance

    CSE 307: Principles of Programming Languages Classes and Inheritance

    OOP Introduction Type & Subtype Inheritance Overloading and Overriding CSE 307: Principles of Programming Languages Classes and Inheritance R. Sekar 1 / 52 OOP Introduction Type & Subtype Inheritance Overloading and Overriding Topics 1. OOP Introduction 3. Inheritance 2. Type & Subtype 4. Overloading and Overriding 2 / 52 OOP Introduction Type & Subtype Inheritance Overloading and Overriding Section 1 OOP Introduction 3 / 52 OOP Introduction Type & Subtype Inheritance Overloading and Overriding OOP (Object Oriented Programming) So far the languages that we encountered treat data and computation separately. In OOP, the data and computation are combined into an “object”. 4 / 52 OOP Introduction Type & Subtype Inheritance Overloading and Overriding Benefits of OOP more convenient: collects related information together, rather than distributing it. Example: C++ iostream class collects all I/O related operations together into one central place. Contrast with C I/O library, which consists of many distinct functions such as getchar, printf, scanf, sscanf, etc. centralizes and regulates access to data. If there is an error that corrupts object data, we need to look for the error only within its class Contrast with C programs, where access/modification code is distributed throughout the program 5 / 52 OOP Introduction Type & Subtype Inheritance Overloading and Overriding Benefits of OOP (Continued) Promotes reuse. by separating interface from implementation. We can replace the implementation of an object without changing client code. Contrast with C, where the implementation of a data structure such as a linked list is integrated into the client code by permitting extension of new objects via inheritance. Inheritance allows a new class to reuse the features of an existing class.
  • INF 102 CONCEPTS of PROG. LANGS Type Systems

    INF 102 CONCEPTS of PROG. LANGS Type Systems

    INF 102 CONCEPTS OF PROG. LANGS Type Systems Instructors: James Jones Copyright © Instructors. What is a Data Type? • A type is a collection of computational entities that share some common property • Programming languages are designed to help programmers organize computational constructs and use them correctly. Many programming languages organize data and computations into collections called types. • Some examples of types are: o the type Int of integers o the type (Int→Int) of functions from integers to integers Why do we need them? • Consider “untyped” universes: • Bit string in computer memory • λ-expressions in λ calculus • Sets in set theory • “untyped” = there’s only 1 type • Types arise naturally to categorize objects according to patterns of use • E.g. all integer numbers have same set of applicable operations Use of Types • Identifying and preventing meaningless errors in the program o Compile-time checking o Run-time checking • Program Organization and documentation o Separate types for separate concepts o Indicates intended use declared identifiers • Supports Optimization o Short integers require fewer bits o Access record component by known offset Type Errors • A type error occurs when a computational entity, such as a function or a data value, is used in a manner that is inconsistent with the concept it represents • Languages represent values as sequences of bits. A "type error" occurs when a bit sequence written for one type is used as a bit sequence for another type • A simple example can be assigning a string to an integer
  • Parametric Polymorphism (Generics) 30 April 2018 Lecturer: Andrew Myers

    Parametric Polymorphism (Generics) 30 April 2018 Lecturer: Andrew Myers

    CS 4120/5120 Lecture 36 Parametric Polymorphism (Generics) 30 April 2018 Lecturer: Andrew Myers Parametric polymorphism, also known as generics, is a programming language feature with implications for compiler design. The word polymorphism in general means that a value or other entity that can have more than one type. We have already talked about subtype polymorphism, in which a value of one type can act like another (super)type. Subtyping places constraints on how we implemented objects. In parametric polymorphism, the ability for something to have more than one “shape” is by introducing a type parameter. A typical motivation for parametric polymorphism is to support generic collection libraries such as the Java Collection Framework. Prior to the introduction of parametric polymorphism, all that code could know about the contents of a Set or Map was that it contained Objects. This led to code that was clumsy and not type-safe. With parametric polymorphism, we can apply a parameterized type such as Map to particular types: a Map String, Point maps Strings to Points. We can also parameterize procedures (functions, methods) withh respect to types.i Using Xi-like syntax, we might write a is_member method that can look up elements in a map: contains K, V (c: Map K, V , k: K): Value { ... } Map K, V h m i h i ...h i p: Point = contains String, Point (m, "Hello") h i Although Map is sometimes called a parameterized type or a generic type , it isn’t really a type; it is a type-level function that maps a pair of types to a new type.
  • Aldor Generics in Software Component Architectures

    Aldor Generics in Software Component Architectures

    Aldor Generics in Software Component Architectures (Spine title: Aldor Generics in Software Component Architectures) (Thesis Format: Monograph) by Michael Llewellyn Lloyd Graduate Program in Computer Science Submitted in partial fulfillment of the requirements for the degree of Masters Faculty of Graduate Studies The University of Western Ontario London, Ontario October, 2007 c Michael Llewellyn Lloyd 2007 THE UNIVERSITY OF WESTERN ONTARIO FACULTY OF GRADUATE STUDIES CERTIFICATE OF EXAMINATION Supervisor Examiners Dr. Stephen M. Watt Dr. David Jeffrey Supervisory Committee Dr. Hanan Lutfiyya Dr. Eric Schost The thesis by Michael Llewellyn Lloyd entitled Aldor Generics in Software Component Architectures is accepted in partial fulfillment of the requirements for the degree of Masters Date Chair of the Thesis Examination Board ii Abstract With the introduction of the Generic Interface Definition Language(GIDL), Software Component Architectures may now use Parameterized types between languages at a high level. Using GIDL, generic programming to be used between programming modules written in different programming languages. By exploiting this mechanism, GIDL creates a flexible programming environment where, each module may be coded in a language appropriate to its function. Currently the GIDL architecture has been implemented for C++ and Java, both object-oriented languages which support com- pile time binding for generic types. This thesis examines an implementation of GIDL for the Aldor language, an imperative language with some aspects of functional pro- gramming, particularly suited for representing algebraic types. In particular, we ex- periment with Aldors implementation of runtime binding for generic types, and show how GIDL allows programmers to use a rich set of generic types across language barriers.
  • Polymorphism

    Polymorphism

    Polymorphism A closer look at types.... Chap 8 polymorphism º comes from Greek meaning ‘many forms’ In programming: Def: A function or operator is polymorphic if it has at least two possible types. Polymorphism i) OverloaDing Def: An overloaDeD function name or operator is one that has at least two Definitions, all of Different types. Example: In Java the ‘+’ operator is overloaDeD. String s = “abc” + “def”; +: String * String ® String int i = 3 + 5; +: int * int ® int Polymorphism Example: Java allows user DefineD polymorphism with overloaDeD function names. bool f (char a, char b) { return a == b; f : char * char ® bool } bool f (int a, int b) { f : int * int ® bool return a == b; } Note: ML Does not allow function overloaDing Polymorphism ii) Parameter Coercion Def: An implicit type conversion is calleD a coercion. Coercions usually exploit the type-subtype relationship because a wiDening type conversion from subtype to supertype is always DeemeD safe ® a compiler can insert these automatically ® type coercions. Example: type coercion in Java Double x; x = 2; the value 2 is coerceD from int to Double by the compiler Polymorphism Parameter coercion is an implicit type conversion on parameters. Parameter coercion makes writing programs easier – one function can be applieD to many subtypes. Example: Java voiD f (Double a) { ... } int Ì double float Ì double short Ì double all legal types that can be passeD to function ‘f’. byte Ì double char Ì double Note: ML Does not perform type coercion (ML has no notion of subtype). Polymorphism iii) Parametric Polymorphism Def: A function exhibits parametric polymorphism if it has a type that contains one or more type variables.
  • 1. with Examples of Different Programming Languages Show How Programming Languages Are Organized Along the Given Rubrics: I

    1. with Examples of Different Programming Languages Show How Programming Languages Are Organized Along the Given Rubrics: I

    AGBOOLA ABIOLA CSC302 17/SCI01/007 COMPUTER SCIENCE ASSIGNMENT ​ 1. With examples of different programming languages show how programming languages are organized along the given rubrics: i. Unstructured, structured, modular, object oriented, aspect oriented, activity oriented and event oriented programming requirement. ii. Based on domain requirements. iii. Based on requirements i and ii above. 2. Give brief preview of the evolution of programming languages in a chronological order. 3. Vividly distinguish between modular programming paradigm and object oriented programming paradigm. Answer 1i). UNSTRUCTURED LANGUAGE DEVELOPER DATE Assembly Language 1949 FORTRAN John Backus 1957 COBOL CODASYL, ANSI, ISO 1959 JOSS Cliff Shaw, RAND 1963 BASIC John G. Kemeny, Thomas E. Kurtz 1964 TELCOMP BBN 1965 MUMPS Neil Pappalardo 1966 FOCAL Richard Merrill, DEC 1968 STRUCTURED LANGUAGE DEVELOPER DATE ALGOL 58 Friedrich L. Bauer, and co. 1958 ALGOL 60 Backus, Bauer and co. 1960 ABC CWI 1980 Ada United States Department of Defence 1980 Accent R NIS 1980 Action! Optimized Systems Software 1983 Alef Phil Winterbottom 1992 DASL Sun Micro-systems Laboratories 1999-2003 MODULAR LANGUAGE DEVELOPER DATE ALGOL W Niklaus Wirth, Tony Hoare 1966 APL Larry Breed, Dick Lathwell and co. 1966 ALGOL 68 A. Van Wijngaarden and co. 1968 AMOS BASIC FranÇois Lionet anConstantin Stiropoulos 1990 Alice ML Saarland University 2000 Agda Ulf Norell;Catarina coquand(1.0) 2007 Arc Paul Graham, Robert Morris and co. 2008 Bosque Mark Marron 2019 OBJECT-ORIENTED LANGUAGE DEVELOPER DATE C* Thinking Machine 1987 Actor Charles Duff 1988 Aldor Thomas J. Watson Research Center 1990 Amiga E Wouter van Oortmerssen 1993 Action Script Macromedia 1998 BeanShell JCP 1999 AngelScript Andreas Jönsson 2003 Boo Rodrigo B.
  • Emacs for Aider: an External Learning System

    Emacs for Aider: an External Learning System

    Emacs For Aider: An External Learning System Jeremy (Ya-Yu) Hsieh B.Sc., University Of Northern British Columbia, 2003 Thesis Submitted In Partial Fulfillment Of The Requirements For The Degree Of Master of Science in Mathematical, Computer, And Physical Sciences (Computer Science) The University Of Northern British Columbia May 2006 © Jeremy (Ya-Yu) Hsieh, 2006 Library and Bibliothèque et 1^1 Archives Canada Archives Canada Published Heritage Direction du Branch Patrimoine de l'édition 395 Wellington Street 395, rue Wellington Ottawa ON K1A 0N4 Ottawa ON K1A 0N4 Canada Canada Your file Votre référence ISBN: 978-0-494-28361-5 Our file Notre référence ISBN: 978-0-494-28361-5 NOTICE: AVIS: The author has granted a non­ L'auteur a accordé une licence non exclusive exclusive license allowing Library permettant à la Bibliothèque et Archives and Archives Canada to reproduce,Canada de reproduire, publier, archiver, publish, archive, preserve, conserve,sauvegarder, conserver, transmettre au public communicate to the public by par télécommunication ou par l'Internet, prêter, telecommunication or on the Internet,distribuer et vendre des thèses partout dans loan, distribute and sell theses le monde, à des fins commerciales ou autres, worldwide, for commercial or non­ sur support microforme, papier, électronique commercial purposes, in microform,et/ou autres formats. paper, electronic and/or any other formats. The author retains copyright L'auteur conserve la propriété du droit d'auteur ownership and moral rights in et des droits moraux qui protège cette thèse. this thesis. Neither the thesis Ni la thèse ni des extraits substantiels de nor substantial extracts from it celle-ci ne doivent être imprimés ou autrement may be printed or otherwise reproduits sans son autorisation.
  • The Aldor-- Language

    The Aldor-- Language

    The Aldor-- language Simon Thompson and Leonid Timochouk Computing Laboratory, University of Kent Canterbury, CT2 7NF, UK ׺ºØÓÑÔ×ÓҸк ºØ ÑÓÓÙÙº ºÙ Abstract This paper introduces the Aldor-- language, which is a functional programming language with dependent types and a powerful, type-based, overloading mechanism. The language is built on a subset of Aldor, the ‘library compiler’ language for the Axiom computer algebra system. Aldor-- is designed with the intention of incorporating logical reasoning into computer algebra computations. The paper contains a formal account of the semantics and type system of Aldor--; a general discus- sion of overloading and how the overloading in Aldor-- fits into the general scheme; examples of logic within Aldor-- and notes on the implementation of the system. 1 Introduction Aldor-- is a dependently-typed functional programming language, which is based on a subset of Aldor [16]. Aldor is a programming language designed to support program development for symbolic mathe- matics, and was used as the library compiler for the Axiom computer algebra system [8]. Aldor-- embodies an approach to integrating computer algebra and logical reasoning which rests on the formulas-as-types principle, sometimes called the Curry-Howard isomorphism [14], under which logical formulas are represented as types in a system of dependent types. Aldor and Axiom have dependent types but, as was argued in earlier papers [11, 15], because there is no evaluation within the type-checker it is not possible to see the Aldor types as providing a faithful representation of logical assertions. A number of other implementations of dependently-typed systems already exist, including Coq [13], Alfa [1] and the Lego proof assistant [10].
  • Obstacl: a Language with Objects, Subtyping, and Classes

    Obstacl: a Language with Objects, Subtyping, and Classes

    OBSTACL: A LANGUAGE WITH OBJECTS, SUBTYPING, AND CLASSES A DISSERTATION SUBMITTED TO THE DEPARTMENT OF COMPUTER SCIENCE AND THE COMMITTEE ON GRADUATE STUDIES OF STANFORD UNIVERSITY IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE DEGREE OF DOCTOR OF PHILOSOPHY By Amit Jayant Patel December 2001 c Copyright 2002 by Amit Jayant Patel All Rights Reserved ii I certify that I have read this dissertation and that in my opin- ion it is fully adequate, in scope and quality, as a dissertation for the degree of Doctor of Philosophy. John Mitchell (Principal Adviser) I certify that I have read this dissertation and that in my opin- ion it is fully adequate, in scope and quality, as a dissertation for the degree of Doctor of Philosophy. Kathleen Fisher I certify that I have read this dissertation and that in my opin- ion it is fully adequate, in scope and quality, as a dissertation for the degree of Doctor of Philosophy. David Dill Approved for the University Committee on Graduate Studies: iii Abstract Widely used object-oriented programming languages such as C++ and Java support soft- ware engineering practices but do not have a clean theoretical foundation. On the other hand, most research languages with well-developed foundations are not designed to support software engineering practices. This thesis bridges the gap by presenting OBSTACL, an object-oriented extension of ML with a sound theoretical basis and features that lend themselves to efficient implementation. OBSTACL supports modular programming techniques with objects, classes, structural subtyping, and a modular object construction system. OBSTACL's parameterized inheritance mechanism can be used to express both single inheritance and most common uses of multiple inheritance.