Eliminating the shortcomings of free datatype definitions

Transcription

1 Research Collection Report Eliminating the shortcomings of free datatype definitions Author(s): Missura, Stephan Albert Publication Date: Permanent Link: Rights / License: In Copyright - Non-Commercial Use Permitted This page was generated automatically upon download from the ETH Zurich Research Collection. For more information please consult the Terms of use. ETH Library

2 Eidgenossische Technische Hochschule Zurich Departement Informatik Institut fur Theoretische Informatik Stephan A. Missura Eliminating the Shortcomings of Free Datatype Denitions December

3 ETH Zurich Departement Informatik Institut fur Theoretische Informatik Prof. Dr. P. Widmayer Stephan A. Missura Institut fur Theoretische Informatik ETH Zentrum CH-8092 Zurich Switzerland This report is available via or as ftp://ftp.inf.ethz.ch/pub/publications/tech-reports/242.ps.gz c 1995 Departement Informatik, ETH Zurich

4 Eliminating the Shortcomings of Free Datatype Denitions Stephan A. Missura Abstract Free datatypes unify the concepts of enumeration types, disjoint unions and recursive types, and are used for dening new terms and operations on them. They correspond to the mathematical concept of term algebras and are a fundamental part of typed functional languages for representing dynamic data structures. But free datatypes are types and not algebras and this results in several drawbacks. The most important is the implicit binding of the constructors to identiers without any explicit binding statement. We discuss these drawbacks and propose an explicit language construct for creating term algebras. This is a small extension for languages that already include constructs for building structures and signatures, and brings us all the advantages of free datatypes without their shortcomings. Several examples are presented in this formalism. 1 Introduction Free datatypes { alsoknown as algebraic, freely generated, inductive, oruser-dened types [20, 22, 24] { are a fundamental part of typed functional languages such as Standard ML [11], Haskell [14], Miranda [23], Opal [7] or the Calculus of Inductive Constructions [15]. They allow the denition of tree-like 1 dynamic data structures without the explicit use of pointers and memory management operations [13] and unify enumeration types, disjoint unions (sum types) and recursive types into one uniform concept. Usually, the constructors can be used in patterns to decompose terms into their building components resulting in more readable function denitions [20, 24]. Furthermore, structural induction can be used as a proof technique [24]. Free datatypes can be compared with the mathematical notion of term algebras (also called free or word algebras) [22, 26] but with the dierence that they are used as types and not as algebraic structures. This results in several drawbacks: Constructor functions are bound \behind the scene", extending implicitly the current scope by new identiers. Only the dened type { the carrier of the term algebra { is bound explicitly to an identier. This results also in an unpleasant mixing of syntax and semantics. Furthermore, the construct can't be used anonymously (similar to functions in ordinary languages, which can'tbe dened anonymously). Research supported by the Swiss National Science Foundation. 1 Assuming eager evaluation of constructors. Languages that use lazy evaluation such as Haskell also allow the building of cyclic structures. 3

5 By extending a language that already includes constructs for building signatures and structures such as Standard ML with an explicit term algebra constructor, we show how the drawbacks of free datatypes can be eliminated. Several examples show the advantages of this term algebraic style of dening free algebras over the style provided by datatype denitions. 2 Free datatypes For discussing the possibilities of free datatypes and their shortcomings we use the syntax of the functional language Standard ML. 2 But in fact any other language with a similar construct could have been used, say Haskell or the Calculus of Inductive Constructions. The general form of a (free) datatype denition in Standard ML can be found in Figure 1. This construct generates n new types T i (1 i n) { the free datatypes { where the T jk (1 j n 1 k m j )aretypes which mayalsocontain T i. Additionally, the datatype construct binds the identier K jk to a new constant (nullary constructor) withtype T j (8j k :1 j n 1 k l j )and the identier C jk to a new function (constructor function) of type T jk -> T j which constructs compound terms of type T j (8j k : 1 j n 1 k m j ). The values denoted by K jk and C jk are called constructors because each value of the free datatype is constructed using the constants and constructor functions. We give now some examples of free datatypes, which should demonstrate the usefulness of them. They allow the denition of enumeration types. We simply enumerate all the constants of the type. For instance, the datatype of booleans is constructed as follows: datatype bool = true false The output of a common Standard ML interpreter 3 datatype bool con false : bool con true : bool would look like: This means that a new type bool is dened and bound to the identier bool. This binding is then inserted in the current scope, as are the bindings of the two nullary constructors true and false to the identiers true and false. 2 A formal semantics for datatypes in Standard ML can be found in [11]. 3 Standard ML of New Jersey, Version 0.93 in our case. 4

6 datatype T 1 = K 11 K 1l 1 C 11 of T 11 C 1m 1 of T 1m 1 and T i = and T n = K n1 K nln C n1 of T n1 C nmn of T nmn Figure 1: General form of free datatypes in Standard ML recursive types. Say, the natural numbers where the nullary constructor zero is the base case, and the constructor succ is used to build \new" natural numbers out of \old" ones: datatype nat = zero succ of nat datatype nat con zero :nat con succ :nat > nat parametrized types. The datatype can be parametrized by a type such as binary trees over an arbitrary type: 4 datatype 'a bintree = empty node of ('a bintree) * 'a * ('a bintree) datatype 'a bintree con empty : 'a bintree con node : 'a bintree 'a 'a bintree > 'a bintree 4 Denoted by thetype variable 'a. 5

7 mutually recursive types: datatype file = text of string dir of directory and directory = entries of file list datatype le con dir : directory > le con text : string > le datatype directory con entries : le list > directory In the next section we discuss several shortcomings of dening free datatypes in the style presented in this section. 3 Shortcomings of free datatypes The binding of the constructors to their corresponding identiers is not done with an explicit binding construct as opposed to the new dened types which are introduced explicitly. In other words: the current environment of bindings of identier to values is implicitly enlarged with new bindings. This unpleasant eect can be demonstrated with the following implementation of a stack using Standard ML's module system. The carrier of the structure is dened as a free datatype: structure Stack = struct datatype 'a stack = empty push of 'a * 'a stack fun pop (push (el, st)) = st fun top (push (el, st)) = el end The components of the structure are not only the type stack and the selectors pop and top, respectively, but also the stack constructors empty and push! Hence, we can't search for labels only on the left side of the binding constructs but we have to search also on the right side in case of a datatype denition. The same problem arises in Modula-2 [27] while importing an enumeration type from an implementation module: the constants of the enumeration type are implicitly imported without being mentioned in the import list. Syntax and semantics are intermixed: the same name is used for the identiers (i.e. syntax) denoting constructors as for the printed form of constructed terms (semantics). 6

8 Not usable anonymously: we have to bind the types in a datatype denition to identiers (the constructors are bound implicitly as seen above), also in cases where it wouldn't be necessary. Curried constructors are not possible because the return type of constructors is implicitly the type to be dened. 5 The needed ingredients for eliminating these shortcomings, namely structures, signatures and an explicit term algebra constructor, are presented in the next two sections. 4 Structures A denition is a binding of an identier { including an explicitly given type { to a value and a structure is a nite collection of denitions. Structures are called environments in MIT Scheme 6 [2], structures or modules in Standard ML and implementation modules in Modula-2. The syntax of structures { inspired by languages for records [4, 10] { is dened by the grammar in Figure 2. Ident represents some class of identiers and Type some class of types which consists at least of a type or kind Type { the type or kind of types [3, 18]. Structure! \< >" j Structure \+" Def inition Def inition! Ident \:" T ype \:=" Expr Figure 2: The syntax of structures < > represents the empty structure and the operator + allows to add further components to the structure. The syntactical form < x 1 :T 1 := e 1 x n :T n := e n > is simply an abbreviation for the structure <> + x 1 :T 1 := e x n :T n := e n 5 The Calculus of Inductive allows curried constructors because the return type is explicitly mentioned and hence can be a function type, too. 6 But not included in the denition of Scheme [1]. 7

9 We give now some examples of structures: Given the type bool for booleans and the constants true and false, we construct the structure Bool consisting of entry T for the carrier and entries t, f for the constants: Bool := < T : Type := bool t : bool := true f : bool := false > The structure of lexically ordered strings: LexString := < T : Type := string cmp : string * string -> bool := lex > The natural numbers with a partial order: PartiallyOrderedNat := < T : Type := nat cmp : nat * nat -> bool := divides > Important: Structures are not types, hence we can't have instances of them. 5 Signatures A declaration is a binding of an identier to a type. A signature is a nite collection of declarations. Standard ML provides this in form of signatures and Modula-2 in form of denition modules. Signatures describe structures and are their types. Because the type of an entry in a signature can depend on other preceding entries, signatures are syntactic sugar for dependent sum types [19]. This denition of a signature is an essential dierence from the usual presentation in algebraic specication [25], where a signature is a pair (S ) consisting of a set S of sorts and a family of operators indexed by non-empty strings of sorts. Hence, sort and operator declarations are handled dierently, as opposed to the more uniform denition we use. In fact, also properties can be modelled in this way [18]. The syntax of signatures { very similar to structures { is dened by the grammar in Figure 3. << represents the empty signature. The operator + allows to extend a given signature by new declarations. A formal treatment of those extensions which are valid, including further operations on signatures, can be found in [18]. 8

10 Signature! \<< " j Signature \+" Declaration Declaration! Ident \:" Type Figure 3: The syntax of signatures As in the case of structures, the syntactical form << x 1 :T 1 x n :T n stands for the signature << + x 1 :T x n :T n Some examples for signatures: A signature which isatype for the preceding example of the structure Bool: BoolSig := << T : Type t : T f : T As one can see the components t and f depend on the rst entry T. A signature for partial orders being a valid type for the structures LexString and PartiallyOrderedNat, respectively: PartialOrder := << T : Type cmp : T * T -> bool 6 Term algebras with free We propose the term algebra constructor free as an explicit language construct for eliminating the shortcomings of datatypes: Q If Sig is the type of signatures then free gets the type s:sig s. This type is a dependent product [24]. Hence, free is a function receiving a signature s as argument and producing a structure of type s, namely the term or free algebra of the signature s [25, 22]. Figure 4 shows how thedatatype declaration of Figure 1 can be transformed into a corresponding signature and what free produces if applied to that signature. 9

11 << T 1 T n :Type :Type K 11 : T 1 K nl1 : T n C 11 : T 11 -> T 1 C nm1 : T nmn -> T n free- < T 1 :Type := new type 1 T n :Type := new type n K 11 : T 1 := new constant 11 K nl1 : T n := new constant nl1 C 11 : T 11 -> T 1 := new constructor 11 C nm1 : T nmn -> T n := new constructor nm1 > Figure 4: The term algebra constructor free We translate now the examples of section 2 into a term algebraic style using free: enumeration types. The free algebra Bool of booleans: Bool := free << bool : Type true : bool false : bool bool := Bool.bool true := Bool.true false := Bool.false recursive types. The natural numbers: Nat := free << nat : Type zero : nat succ : nat -> nat nat := Nat.nat zero := Nat.zero succ := Nat.succ parametrized types. We need a type constructor tree as a component for simulating parametrized datatypes: Tree := free << tree : Type -> Type empty : tree 'a node : (tree 'a) * 'a * (tree 'a) -> (tree 'a) 10

12 tree := Tree.tree empty := Tree.empty node := Tree.node mutually recursive types: FileDir := free << file : Type directory : Type text : string -> file dir : directory -> file entries : list(file) -> directory filet := FileDir.file dirt := FileDir.directory textc := FileDir.text dirc := FileDir.dir entriesc := FileDir.entries We had to write more lines code than the corresponding datatype denition because all bindings are now explicit (clearly, it is not mandatory to have all bindings globally visible). Hence, no binding happens \behind the user's back". Helpful for dealing with free is an open construct, which adds all the bindings of a structure to the current environment (as in Standard ML). It eliminates the need for intermediate identiers. Hence, the example of booleans simply becomes: open (free << bool : Type true : bool false : bool ) As a last example we rewrite the stack structure mentioned in section 3 into the term algebraic style. The example shows also that the possibility of adding entries to a given structure is essential in this formalism: Stack := free << stack : Type -> Type empty : stack('a) push : 'a * stack('a) -> stack('a) + pop : stack('a) -> stack('a) :=... + top : stack('a) -> 'a :=... First, we construct the free algebra consisting of a type constructor stack, the constant empty and the constructor push. Afterwards, we extend this algebra by the selector functions pop and top (which implementations are omitted). 11

13 7 Conclusions The concept of term algebras including their construction is an often-used concept in the mathematical world, especially in logic, model theory and category theory [6, 21]. They are also well-known in computer science, say in algebraic specication for describing abstract datatypes [26] or recursive datatypes [22]. Despite this fact, no language is known to the author that uses an explicit language construct for creating term algebras from signatures: Neither in functional languages, in typed logic programming languages, say Godel [12], nor in logical environments such as IMPS [8] or Nuprl [5], which all use some form of datatypes for creating term algebras. The same situation can be found in specication systems such as OBJ3 [9], which creates term algebras implicitly from executable specications or Tecton [16] which does not provide both structures and signatures. Also in the literature about recursive datatypes the authors use sometimes the phrase \word algebra" for describing datatypes but do not use any explicit term algebra constructor [13, 22]. We rst discussed the shortcomings of using free datatypes for constructing free algebras. Then, we showed that all these drawbacks can be eliminated by introducing the term algebra constructor free as an explicit language construct. In particular, all identier{ value bindings are now explicit. The result is a simpler understanding of what is going on semantically than in the case of free datatypes. Hence, this term algebraic style of dening new types and constructors is also helpful in teaching the concept of free algebras which can be a rather cumbersome task using datatypes. A prototype implementation of free for a language with rst class structures and signatures was done by Gerard Milmeister [17]. Future work consists of integrating the free construct into a functional environment and providing an operational semantics. Acknowledgments. I would like to thank Manuel Bronstein, Georgios Grivas, Christian Luginbuhl, Roman Maeder, Niklaus Mannhart and Gerard Milmeister for reviewing draft versions of this paper. References [1] H. Abelson et al. Revised 4 Report on the Algorithmic Language Scheme. Technical report, Articial Intelligence Laboratory, Massachusetts Institute of Technology (MIT), Cambridge, Massachusetts, November [2] H. Abelson and G. J. Sussman. Structure and Interpretation of Computer Programs. The MIT Press, Cambridge, Mass., [3] L. Cardelli. Typeful Programming. Technical Report 45, DEC Systems Research Center, [4] L. Cardelli and J.C. Mitchell. Operations on Records. Mathematical Structures in Computer Science, 1(1):3{48, [5] R.L. Constable et al. Implementing Mathematics with the Nuprl Proof Development System. Prentice-Hall,

14 [6] John Barwise (ed.). Handbook of Mathematical Logic. North-Holland Publishing Company, [7] Jurgen Exner. The OPAL tutorial. Technical Report 94-9, TU Berlin, May [8] W. M. Farmer, J. D. Guttman, and F. J. Thayer. The imps user's manual. Technical Report M93-B138, The MITRE Corporation, 202 Burlington Road, Bedford, MA , USA, [9] Joseph A. Goguen et al. Introducing OBJ. Technical report, SRI International, March [10] Carl A. Gunter. Semantics of Programming Languages: Structures and Techniques. Foundations of Computing Series. The MIT Press, [11] Robert Harper, Robin Milner, and Mads Tofte. The Denition of Standard ML. The MIT Press, [12] Patricia Hill and John Lloyd. The Godel Programming Language. The MIT Press, [13] C.A.R. Hoare. Recursive data structures. International Journal of Computer and Information Sciences, June [14] P.R. Hudak et al. Report on the programming language Haskell, a non-strict purely functional language, Version 1.2. ACM SIGPLAN Notices, [15] Gerard Huet et al. The Coq Proof Assistant, User's Guide, Version Technical report, INRIA, [16] Deepak Kapur and David R. Musser. Tecton: a framework for specifying and verifying generic system components. Technical Report RPI{92{20, Department of Computer Science, Rensselaer Polytechnic Institute, Troy, New York 12180, July [17] Gerard Milmeister. Functional Kernel with Modules, Diploma Thesis, ETH Zurich. [18] Stephan A. Missura. Theories = Signatures + Propositions Used as Types. In Jacques Calmet and John A. Campbell, editors, Integrating Symbolic Mathematical Computation and Articial Intelligence (AISMC-2),volume 958 of Lecture Notes in Computer Science. Springer Verlag, August [19] J. Mitchell and R. Harper. The Essence of ML. In Conference Record ofacm Symposium on Principles of Programming Languages, pages 28{46, [20] Simon L. Peyton Jones. The Implementation of Functional Programming Languages. Prentice Hall International, [21] B. Pierce. Basic Category Theory for Computer Scientists. MIT Press, [22] C. Reade. Elements of Functional Programming. Addison-Wesley, [23] David A. Turner. An overview of Miranda. In David A. Turner, editor, Research topics in Functional Programming. Addison Wesley,

15 [24] Raymond Turner. Constructive Foundations for Functional Languages. McGraw-Hill, [25] Jan van Leeuwen, editor. Formal Models and Semantics, volume B of Handbook of Theoretical Computer Science. Elsevier, [26] Martin Wirsing. Algebraic specication. In Jan van Leeuwen, editor, Formal Models and Semantics, volume B of Handbook of Theoretical Computer Science, chapter 13, pages 675{788. Elsevier, [27] Niklaus Wirth. Programming in Modula-2. Springer,