The Derivative of a Regular Type Is Its Type of One-Hole Contexts

Total Page:16

File Type:pdf, Size:1020Kb

The Derivative of a Regular Type Is Its Type of One-Hole Contexts The Derivative of a Regular Type is its Type of One-Hole Contexts Extended Abstract Conor McBride Abstract subtraction, an operation inherently troubled by the need to subtract only smaller things from larger, but as the in- version of a kind of addition (see figure 1). Polymorphic regular types are tree-like datatypes gen- erated by polynomial type expressions over a set of free variables and closed under least fixed point. The ‘equal- ity types’ of Core ML can be expressed in this form. Given ¡ such a type expression with ¢ free, this paper shows a = + way to represent the one-hole contexts for elements of ¢ within elements of ¡ , together with an operation which will plug an element of ¢ into the hole of such a context. One-hole contexts are given as inhabitants of a regular ¡ type £¥¤ , computed generically from the syntactic struc- ture of ¡ by a mechanism better known as partial differ- Figure 1: a tree as a one-hole context ‘plus’ a subtree entiation. The relevant notion of containment is shown to be appropriately characterized in terms of derivatives and This paper exhibits a similar technique, defined more for- plugging in. The technology is then exploited to give the mally, which is generic for a large class of tree-like data one-hole contexts for sub-elements of recursive types in a structures—the ‘regular datatypes’. These are essentially manner similar to Huet’s ‘zippers’[Hue97]. the ‘equality types’ of core ML, presented as polynomial type expressions closed under least fixed point. In partic- ular, I will define and characterize two operations: 1 Introduction § on types, computing for each regular recursive Gerard´ Huet’s delightful paper ‘The Zipper’ [Hue97] de- datatype its type of one-hole contexts; fines a representation of tree-like data decomposed into a subtree of interest and its surroundings. He shows us in- § on terms, computing a ‘big’ term by plugging a formally how to equip a datatype with an associated type ‘small’ term into a one-hole context. of ‘zippers’—one-hole contexts representing a tree with one subtree deleted. Zippers collect the subtrees forking The first of these operations is given by recursion on the off step by step from the path which starts at the hole and structure of the algebraic expressions which ‘name’ types. returns to the root. This type of contexts is thus indepen- As I wrote down the rules corresponding to the empty dent of the particular tree being decomposed or the sub- type, the unit type, sums and products, I was astonished tree in the hole. Decomposition is seen not as a kind of to find that Leibniz had beaten me to them by several cen- ¦ Department of Computer Science, University of Durham, turies: they were exactly the rules of differentiation I had [email protected] learned as a child. 1 1.1 Motivating Examples btree @¨ 2 btree How can we describe the one-hole contexts of a recur- Now imagine similar journeys list ttree for ternary sive type? Huet suggests that we regard them as journeys trees: ‘backwards’ from hole to root, recording what we pass by on the way. I propose to follow his suggestion, except that 3 ttree ¨ 1 ttree I will start at the root and work my way ‘forwards’ to the hole. Both choices have their uses: ‘backwards’ is better for ‘tree editing’ applications, but the ‘forwards’ approach Each step chooses one of three directions, and remembers is conceptually simpler. two bypassed trees, so Consider such journeys within binary trees: 2 ttree ¨ 3 ttree © btree ¨ leaf node btree btree It looks remarkably like the type of steps is calculated by differentiating the original datatype. In fact, this is exactly At each point, we are either at the hole or we must step what is happening, as we shall see when we examine how further in—our journey is a list of steps, list btree for to compute the description of the one-hole contexts for some appropriate step type btree , but what? At each regular datatypes. step, we must record our binary choice of left or right, together with the btree we passed by. We may take 2 Presenting the Regular Types btree ¨ bool btree 1 In order to give a precise treatment of ‘differentiating a We can define the ‘plugging in’ operation as follows datatype’, we must be precise about the expressions which define them. In particular, the availability of fixed points btree btree requires us to consider the binding of fresh type variables. btree There is much activity in this area of research, but this is not the place to rehearse its many issues. The approach true node I take in this paper relativizes regular type expressions to ¥ false node finite sequences of available free names. I then explain !"!# list btree btree how to interpret such expressions relative to an environ- !"! $ btree ment which interprets those names. % & $ I choose to give inductive definitions in natural deduc- (')'*!"! , !"! - + $ tion style. Although this requires more space than the datatype declarations of conventional programming lan- We might define btree more algebraically as the sum guages, they allow dependent families to be presented (i.e. ‘choice’) of the unique leaf with nodes pairing two much more clearly: even ‘nested’ types [BM98, BP99] subtrees—powers denote repeated product: must be defined uniformly over their indices, whilst the full notion of family allows constructors to apply only 2 at particular indices. I also give type signatures to de- btree ¨ 1 btree fined functions in this way, preferring to present the uni- versal quantification inherent in their type dependency via Correspondingly, we might write schematic use of variables, rather than by complex and in- 1 >[email protected]/+B:C6 Huet would write .0/+12143537698;:=< scrutable formulae. 2 2.1 Sequences of Distinct Names family Reg D in figure 2. Firstly, we embed3 type vari- D ables D in Reg , then we give the building blocks for Let us presume the existence of an infinite2 set Name of polynomials and least fixed point. names, equipped with a decidable equality. We may think D of Name as being ‘string’. The set NmSeq may then be NmSeq D defined to contain the finite sequences of distinct names. Reg Set Each such sequence can be viewed ‘forgetfully’ as a set. D ¢ D ¢ Reg D ¡ D NmSeq D Reg D O ¡ D Name Set Set 0 Reg Reg O ¡ D D D Reg ¢ ¢GF D D ¡ NmSeq Name O D=H E 1 Reg Reg ¢ NmSeq NmSeq O P D=H Reg ¢ P D Q ¢ . Reg I shall always use names in a well-founded manner. The P D=H D ¡ D D ¢ ‘explanation’ of some name ¢ from some sequence will Reg Reg Reg P D ¡ D=H O © ¢ ¢ = Reg ¤ Reg involve only ‘prior’ names—intuitively, those which have O already been explained. It is therefore important to define DGI for any such pair, the restriction ¢ , being the sequence D Figure 2: descriptions of regular types of names from prior to ¢ . D D The last two constructors may seem mysterious. How- NmSeq ¢ DGI ever, the redundancy they introduce will save us work ¢ NmSeq when we come to interpret these descriptions of types. E I D D=H We could choose to interpret only Reg , the closed de- ¢ ¢ KJML I DGI D=H scriptions, keeping the open types underwater like the ¢ ¢ ¢N dangerous bits of an iceberg. This would require us to substitute for free names whenever they become exposed, As equality on names is decidable, I shall freely allow for example, when expanding a fixed point. We would in names to occur nonlinearly in patterns. In order to re- turn be forced to take account of the equational properties cover the disjointness of patterns without recourse to pri- of substitutions and prove closure properties with respect JML oritizing them, I introduce the notation ¢ to mean ‘any to them. I dispense with substitution. J except ¢ ’. Correspondingly, each clause of such a defi- nition holds (schematically) as an equation. I nonetheless The alternative I have adopted is to interpret open descrip- tions in environments which explain their free names. The write to indicate a directed computation rule, reserving two unusual constructors above perform the rolesˆ of defi- ¨ for equational propositions. nition and weakening, respectively growing and shrinking the environment within their scope. Definition replaces 2.2 Describing the Regular Types substitution and weakening adds more free names without modifying ‘old’ descriptions. This avoids the propagation of substitutions through the syntactic structure and hence The regular types over given free names, or rather, the ex- concerns about capture—we shall only ever interpret the pressions which describe them are given by the inductive ‘value’ of a variable in its binding-time environment. 2By ‘infinite’, I mean that I can always choose a fresh name if I need to create a new binding. 3In fact I am abusing notation by suppressing a constructor symbol. 3 D ¡ D 2.3 Type Environments R Env Reg % % & & ¡ R Set D % % & & I A type environment for a given name sequence asso- R ¢ RTSU¢ D % % & & ciates each ¢ in with a type description over the prior R ¢ DGI ¢ % & & % % & & names, . % ¡ R R % % & & % % & & O ¡ ¡ R inl R inr O O D % % & & % % & & ¡ NmSeq # D R R XZY % % & & X Y % % & & O ¡ Env Set H R R 1 O & & % % P P E E Q R © ¢ ¢ Env = . % % & & P Q D=H D D R ¢ con . R ¢ NmSeq Env Reg H D=H O % % & & % % & & H P ¡ ¢ ¢ R = Env O R ¢ R = % % & & % % & & O P H ¡ R © ¢ R ¢ = = ¤ O O We may equip environments with operators for restriction (extracting the prefix prior to a given name) and projection I Figure 3: the data in regular types ¢ (looking up a name’s associated type description).
Recommended publications
  • A Type and Scope Safe Universe of Syntaxes with Binding: Their Semantics and Proofs
    ZU064-05-FPR jfp19 26 March 2020 16:6 Under consideration for publication in J. Functional Programming 1 A Type and Scope Safe Universe of Syntaxes with Binding: Their Semantics and Proofs GUILLAUME ALLAIS, ROBERT ATKEY University of Strathclyde (UK) JAMES CHAPMAN Input Output HK Ltd. (HK) CONOR MCBRIDE University of Strathclyde (UK) JAMES MCKINNA University of Edinburgh (UK) Abstract Almost every programming language’s syntax includes a notion of binder and corresponding bound occurrences, along with the accompanying notions of α-equivalence, capture-avoiding substitution, typing contexts, runtime environments, and so on. In the past, implementing and reasoning about programming languages required careful handling to maintain the correct behaviour of bound variables. Modern programming languages include features that enable constraints like scope safety to be expressed in types. Nevertheless, the programmer is still forced to write the same boilerplate over again for each new implementation of a scope safe operation (e.g., renaming, substitution, desugaring, printing, etc.), and then again for correctness proofs. We present1 an expressive universe of syntaxes with binding and demonstrate how to (1) implement scope safe traversals once and for all by generic programming; and (2) how to derive properties of these traversals by generic proving. Our universe description, generic traversals and proofs, and our examples have all been formalised in Agda and are available in the accompanying material available online at https://github.com/gallais/generic-syntax. 1 Introduction In modern typed programming languages, programmers writing embedded DSLs (Hudak (1996)) and researchers formalising them can now use the host language’s type system to help them.
    [Show full text]
  • Agda User Manual Release 2.6.3
    Agda User Manual Release 2.6.3 The Agda Team Sep 23, 2021 Contents 1 Overview 3 2 Getting Started 5 2.1 What is Agda?..............................................5 2.2 Installation................................................7 2.3 ‘Hello world’ in Agda.......................................... 13 2.4 A Taste of Agda............................................. 14 2.5 A List of Tutorials............................................ 22 3 Language Reference 25 3.1 Abstract definitions............................................ 25 3.2 Built-ins................................................. 27 3.3 Coinduction............................................... 40 3.4 Copatterns................................................ 42 3.5 Core language.............................................. 45 3.6 Coverage Checking............................................ 48 3.7 Cubical.................................................. 51 3.8 Cumulativity............................................... 65 3.9 Data Types................................................ 66 3.10 Flat Modality............................................... 69 3.11 Foreign Function Interface........................................ 70 3.12 Function Definitions........................................... 75 3.13 Function Types.............................................. 78 3.14 Generalization of Declared Variables.................................. 79 3.15 Guarded Cubical............................................. 84 3.16 Implicit Arguments...........................................
    [Show full text]
  • Current Issue of FACS FACTS
    Issue 2021-2 July 2021 FACS A C T S The Newsletter of the Formal Aspects of Computing Science (FACS) Specialist Group ISSN 0950-1231 FACS FACTS Issue 2021-2 July 2021 About FACS FACTS FACS FACTS (ISSN: 0950-1231) is the newsletter of the BCS Specialist Group on Formal Aspects of Computing Science (FACS). FACS FACTS is distributed in electronic form to all FACS members. Submissions to FACS FACTS are always welcome. Please visit the newsletter area of the BCS FACS website for further details at: https://www.bcs.org/membership/member-communities/facs-formal-aspects- of-computing-science-group/newsletters/ Back issues of FACS FACTS are available for download from: https://www.bcs.org/membership/member-communities/facs-formal-aspects- of-computing-science-group/newsletters/back-issues-of-facs-facts/ The FACS FACTS Team Newsletter Editors Tim Denvir [email protected] Brian Monahan [email protected] Editorial Team: Jonathan Bowen, John Cooke, Tim Denvir, Brian Monahan, Margaret West. Contributors to this issue: Jonathan Bowen, Andrew Johnstone, Keith Lines, Brian Monahan, John Tucker, Glynn Winskel BCS-FACS websites BCS: http://www.bcs-facs.org LinkedIn: https://www.linkedin.com/groups/2427579/ Facebook: http://www.facebook.com/pages/BCS-FACS/120243984688255 Wikipedia: http://en.wikipedia.org/wiki/BCS-FACS If you have any questions about BCS-FACS, please send these to Jonathan Bowen at [email protected]. 2 FACS FACTS Issue 2021-2 July 2021 Editorial Dear readers, Welcome to the 2021-2 issue of the FACS FACTS Newsletter. A theme for this issue is suggested by the thought that it is just over 50 years since the birth of Domain Theory1.
    [Show full text]
  • Objective Metatheory of Cubical Type Theories (Thesis Proposal) Jonathan Sterling August 15, 2020
    Objective Metatheory of Cubical Type Theories (thesis proposal) Jonathan Sterling August 15, 2020 School of Computer Science Carnegie Mellon University Pittsburgh, PA 15213 Thesis Committee: Robert Harper, Chair Lars Birkedal Jeremy Avigad Karl Crary Favonia Submitted in partial fulfillment of the requirements for the degree of Doctor of Philosophy. Copyright © 2020 Jonathan Sterling I gratefully acknowledge the support of the Air Force Office of Scientific Research through MURI grant FA9550-15-1-0053. Any opinions, findings and conclusions or recommendations expressed in this material are those of the author and do not necessarily reflect the views of the AFOSR. Contents 1 Introduction 1 1.1 Computation in dependent type theory ................. 1 1.2 Syntactic, phenomenal, and semantic aspects of equality . 3 1.3 Subjective metatheory: the mathematics of formalisms . 6 1.4 Objective metatheory: a syntax-invariant perspective . 6 1.5 Towards principled implementation of proof assistants . 20 1.6 Thesis Statement ............................. 20 1.7 Acknowledgments ............................. 21 2 Background and Prior Work 23 2.1 RedPRL: a program logic for cubical type theory . 23 2.2 The redtt proof assistant ......................... 28 2.3 XTT: cubical equality and gluing .................... 39 3 Proposed work 45 3.1 Algebraic model theory .......................... 46 3.2 Contexts and injective renamings .................... 46 3.3 Characterizing normal forms ....................... 48 3.4 Normalization of cartesian cubical type theory . 49 3.5 redtt reloaded: abstract elaboration ................... 50 3.6 Timeline and fallback positions ..................... 50 A redtt: supplementary materials 51 A.1 The RTT core language ......................... 51 A.2 Normalization by evaluation for RTT . 59 A.3 Elaboration relative to a boundary ..................
    [Show full text]
  • Haskell Communities and Activities Report
    Haskell Communities and Activities Report http://www.haskell.org/communities/ Eighth Edition – May 13, 2005 Andres L¨oh (ed.) Perry Alexander Lloyd Allison Tiago Miguel Laureano Alves Krasimir Angelov Alistair Bayley J´er´emy Bobbio Bj¨orn Bringert Niklas Broberg Paul Callaghan Mark Carroll Manuel Chakravarty Olaf Chitil Koen Claessen Catarina Coquand Duncan Coutts Philippa Cowderoy Alain Cr´emieux Iavor Diatchki Atze Dijkstra Shae Erisson Sander Evers Markus Forsberg Simon Foster Leif Frenzel Andr´eFurtado John Goerzen Murray Gross Walter Gussmann Jurriaan Hage Sven Moritz Hallberg Thomas Hallgren Keith Hanna Bastiaan Heeren Anders H¨ockersten John Hughes Graham Hutton Patrik Jansson Johan Jeuring Paul Johnson Isaac Jones Oleg Kiselyov Graham Klyne Daan Leijen Huiqing Li Andres L¨oh Rita Loogen Salvador Lucas Christoph Luth¨ Ketil Z. Malde Christian Maeder Simon Marlow Conor McBride John Meacham Serge Mechveliani Neil Mitchell William Garret Mitchener Andy Moran Matthew Naylor Rickard Nilsson Jan Henry Nystr¨om Sven Panne Ross Paterson Jens Petersen John Peterson Simon Peyton-Jones Jorge Sousa Pinto Bernie Pope Claus Reinke Frank Rosemeier David Roundy George Russell Chris Ryder David Sabel Uwe Schmidt Martijn Schrage Peter Simons Anthony Sloane Dominic Steinitz Donald Bruce Stewart Martin Sulzmann Autrijus Tang Henning Thielemann Peter Thiemann Simon Thompson Phil Trinder Arjan van IJzendoorn Tuomo Valkonen Eelco Visser Joost Visser Malcolm Wallace Ashley Yakeley Jory van Zessen Bulat Ziganshin Preface You are reading the 8th edition of the Haskell Communities and Activities Report (HCAR). These are interesting times to be a Haskell enthusiast. Everyone seems to be talking about darcs (→ 6.3) and Pugs (→ 6.1) these days, and it is nice to see Haskell being mentioned in places where it usually was not.
    [Show full text]
  • 162581776.Pdf
    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by The IT University of Copenhagen's Repository Verification of High-Level Transformations with Inductive Refinement Types Ahmad Salim Al-Sibahi Thomas P. Jensen DIKU/Skanned.com/ITU INRIA Rennes Denmark France Aleksandar S. Dimovski Andrzej Wąsowski ITU/Mother Teresa University, Skopje ITU Denmark/Macedonia Denmark Abstract 1 Introduction High-level transformation languages like Rascal include ex- Transformations play a central role in software development. pressive features for manipulating large abstract syntax trees: They are used, amongst others, for desugaring, model trans- first-class traversals, expressive pattern matching, backtrack- formations, refactoring, and code generation. The artifacts ing and generalized iterators. We present the design and involved in transformations—e.g., structured data, domain- implementation of an abstract interpretation tool, Rabit, for specific models, and code—often have large abstract syn- verifying inductive type and shape properties for transfor- tax, spanning hundreds of syntactic elements, and a corre- mations written in such languages. We describe how to per- spondingly rich semantics. Thus, writing transformations form abstract interpretation based on operational semantics, is a tedious and error-prone process. Specialized languages specifically focusing on the challenges arising when analyz- and frameworks with high-level features have been devel- ing the expressive traversals and pattern matching. Finally, oped to address this challenge of writing and maintain- we evaluate Rabit on a series of transformations (normaliza- ing transformations. These languages include Rascal [28], tion, desugaring, refactoring, code generators, type inference, Stratego/XT [12], TXL [16], Uniplate [31] for Haskell, and etc.) showing that we can effectively verify stated properties.
    [Show full text]
  • Domain-Specific Languages for Modeling and Simulation
    Domain-specifc Languages for Modeling and Simulation Dissertation zur Erlangung des akademischen Grades Doktor-Ingenieur (Dr.-Ing.) der Fakultät für Informatik und Elektrotechnik der Universität Rostock vorgelegt von Tom Warnke, geb. am 25.01.1988 in Malchin aus Rostock Rostock, 14. September 2020 https://doi.org/10.18453/rosdok_id00002966 Dieses Werk ist lizenziert unter einer Creative Commons Namensnennung - Weitergabe unter gleichen Bedingungen 4.0 International Lizenz. Gutachter: Prof. Dr. Adelinde M. Uhrmacher (Universität Rostock) Prof. Rocco De Nicola (IMT Lucca) Prof. Hans Vangheluwe (Universität Antwerpen) Eingereicht am 14. September 2020 Verteidigt am 8. Januar 2021 Abstract Simulation models and simulation experiments are increasingly complex. One way to handle this complexity is developing software languages tailored to specifc application domains, so-called domain-specifc languages (DSLs). This thesis explores the potential of employing DSLs in modeling and simulation. We study diferent DSL design and implementation techniques and illustrate their benefts for expressing simulation models as well as simulation experiments with several examples. Regarding simulation models, we focus on discrete-event models based on continuous- time Markov chains (CTMCs). Most of our work revolves around ML-Rules, an rule-based modeling language for biochemical reaction networks. First, we relate the expressive power of ML-Rules to other currently available modeling languages for this application domain. Then we defne the abstract syntax and operational semantics for ML-Rules, mapping models to CTMCs in an unambiguous and precise way. Based on the formal defnitions, we present two approaches to implement ML-Rules as a DSL. The core of both implementations is fnding the matches for the patterns on the left side of ML-Rules’ rules.
    [Show full text]
  • First-Class Type Classes
    First-Class Type Classes Matthieu Sozeau1 and Nicolas Oury2 1 Univ. Paris Sud, CNRS, Laboratoire LRI, UMR 8623, Orsay, F-91405 INRIA Saclay, ProVal, Parc Orsay Universit´e, F-91893 [email protected] 2 University of Nottingham [email protected] Abstract. Type Classes have met a large success in Haskell and Is- abelle, as a solution for sharing notations by overloading and for spec- ifying with abstract structures by quantification on contexts. However, both systems are limited by second-class implementations of these con- structs, and these limitations are only overcomed by ad-hoc extensions to the respective systems. We propose an embedding of type classes into a dependent type theory that is first-class and supports some of the most popular extensions right away. The implementation is correspond- ingly cheap, general and integrates well inside the system, as we have experimented in Coq. We show how it can be used to help structured programming and proving by way of examples. 1 Introduction Since its introduction in programming languages [1], overloading has met an important success and is one of the core features of object–oriented languages. Overloading allows to use a common name for different objects which are in- stances of the same type schema and to automatically select an instance given a particular type. In the functional programming community, overloading has mainly been introduced by way of type classes, making ad-hoc polymorphism less ad hoc [17]. A type class is a set of functions specified for a parametric type but defined only for some types.
    [Show full text]
  • Presheaf Semantics for Guarded Dependent Type Theory
    23rd International Conference on Types for Proofs and Programs TYPES 2017 Budapest, Hungary, 29 May - 1 June 2017 Abstracts Department of Programming Languages and Compilers, Faculty of Informatics, E¨otv¨osLor´andUniversity Budapest, 2017 23rd International Conference on Types for Proofs and Programs, TYPES 2017 Budapest, Hungary, 29 May - 1 June 2017 Abstracts http://types2017.elte.hu Edited by Ambrus Kaposi Department of Programming Languages and Compilers Faculty of Informatics E¨otv¨osLor´andUniversity P´azm´any P´eters´et´any 1/C, 1117 Budapest, Hungary http://www.inf.elte.hu Cover design by Andr´asF´orizs ISBN 978-963-284-883-9 (print) ISBN 978-963-284-884-6 (pdf) c 2017 the editor and authors Preface This volume contains the abstracts of the talks presented at the 23rd International Conference on Types for Proofs and Programs, TYPES 2017, to take place in Budapest, Hungary, 29 May - 1 June 2017. The TYPES meetings are a forum to present new and on-going work in all aspects of type theory and its applications, especially in formalised and computer assisted reasoning and computer programming. The meetings from 1990 to 2008 were annual workshops of a sequence of five EU funded networking projects. Since 2009, TYPES has been run as an independent conference series. Previous TYPES meetings were held in Antibes (1990), Edinburgh (1991), B˚astad(1992), Nijmegen (1993), B˚astad (1994), Torino (1995), Aussois (1996), Kloster Irsee (1998), L¨okeberg (1999), Durham (2000), Berg en Dal near Nijmegen (2002), Torino (2003), Jouy-en-Josas near Paris (2004), Nottingham (2006), Cividale del Friuli (2007), Torino (2008), Aussois (2009), Warsaw (2010), Bergen (2011), Toulouse (2013), Paris (2014), Tallinn (2015), Novi Sad (2016).
    [Show full text]
  • Trends in Functional Programming, Transformational and Programming Generic Programming to Type Checking and Volume6 Designing New Classes of Data Types
    This book presents latest research developments van Eekelen Trends in in the area of functional programming. The contributions in this volume cover a wide Functional range of topics from theory, formal aspects of Trends in functional programming, transformational and Programming generic programming to type checking and Volume6 designing new classes of data types. Functional Not all papers in this book belong to the Edited by Marko Van Eekelen category of research papers. Also, the categories of project description (at the start Trends in Trends Functional Programming Programming of a project) and project evaluation (at the end of a project) papers are represented. Particular trends in this volume are: T software engineering techniques such Volume6 as metrics and refactoring for high-level programming languages; T generation techniques for data type elements Edited by Marko van Eekelen as well as for lambda expressions; T analysis techniques for resource consumption with the use of high-level programming languages for embedded systems; T widening and strengthening of the theoretical foundations. The TFP community (www.tifp.org) is dedicated to promoting new research directions related to the field of functional programming and to investigate the relationships of functional 6 Volume programming with other branches of computer science. It is designed to be a platform for novel and upcoming research. Dr. Marko van Eekelen is an associate professor in the Security of Systems Department of the Institute for Computing and Information Sciences, Radboud University, Nijmegen. intellect PO Box 862, Bristol BS99 1DE, United Kingdom / www.intellectbooks.com intellect ISBN 978-1-84150-176-5 0 0 9 781841 501765 TFP6Prelims 1/6/07 14:30 Page 1 Trends in Functional Programming Volume 6 Edited by Marko van Eekelen Radboud University, Nijmegen TFP6Prelims 1/6/07 14:30 Page 2 First Published in the UK in 2007 by Intellect Books, PO Box 862, Bristol BS99 1DE, UK First published in the USA in 2007 by Intellect Books, The University of Chicago Press, 1427 E.
    [Show full text]
  • Extensible Languages for Flexible and Principled Domain Abstraction
    Extensible Languages for Flexible and Principled Domain Abstraction Dissertation for the degree of Doctor of Natural Sciences Submitted by Sebastian Thore Erdweg, MSc born March 14, 1985 in Frankfurt/Main Department of Mathematics and Computer Science Philipps-Universität Marburg Referees: Prof. Dr. Klaus Ostermann Dr. Eelco Visser Prof. Dr. Ralf Lämmel Submitted November 28, 2012. Defended March 06, 2013. Marburg, 2013. Erdweg, Sebastian: Extensible Languages for Flexible and Principled Domain Abstraction Dissertation, Philipps-Universität Marburg (1180), 2013. Curriculum vitae 2007, Bachelor of Science, TU Darmstadt 2009, Master of Science, Aarhus University Cover photo by Tellerdreher Photography, 2012. Abstract Most programming languages are designed for general-purpose software deve- lopment in a one-size-fits-all fashion: They provide the same set of language features and constructs for all possible applications programmers ever may want to develop. As with shoes, the one-size-fits-all solution grants a good fit to few applications only. The trend toward domain-specific languages, model-driven development, and language-oriented programming counters general-purpose languages by promo- ting the use of domain abstractions that facilitate domain-specific language features and constructs tailored to certain application domains. In particular, domain abstraction avoids the need for encoding domain concepts with general- purpose language features and thus allows programmers to program at the same abstraction level as they think. Unfortunately, current approaches to domain abstraction cannot deliver on the promises of domain abstraction. On the one hand, approaches that target internal domain-specific languages lack flexibility regarding the syntax, static checking, and tool support of domain abstractions, which limits the level of actually achieved domain abstraction.
    [Show full text]
  • Generic Views on Data Types
    Generic Views on Data Types Stefan Holdermans Johan Jeuring Andres Loh¨ institute of information and computing sciences, utrecht university technical report UU-CS-2005-012 www.cs.uu.nl Generic Views on Data Types Stefan Holdermans Johan Jeuring Andres Loh¨ Institute of Information and Computing Sciences Utrecht University P.O. Box 80.089 3508 TB Utrecht, the Netherlands {stefan,johanj,andres}@cs.uu.nl Abstract A generic function is defined by induction on the structure of types. The structure of a data type can be defined in several ways. For example, in PolyP a pattern functor gives the structure of a data type viewed as a fixed point, and in Generic Haskell a structural representation type gives an isomorphic type view of a data type in terms of sums of products. Depending on this generic view on the structure of data types, some generic functions are easier, more difficult, or even impossible to define. Furthermore, the efficiency of some generic functions can be improved by choosing a different view. This paper introduces generic views on data types and shows why they are useful. Furthermore, it discusses how to add new generic views to Generic Haskell, an extension of the functional programming language Haskell that supports the construction of generic functions. The separation between inductive definitions on type structure and generic views allows us to view many approaches to generic programming in a single framework. 1. Introduction A generic function is defined by induction on the structure of types. Several approaches to generic programming [15, 10, 19, 18, 14] have been developed in the last decade.
    [Show full text]