DOCSLIB.ORG

Application of Category-Theory Methods to the Design of a System of Modules for a Functional Programming Language

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Application of Category-Theory Methods to the Design of a System of Modules for a Functional Programming Language Warsaw University Faculty of Mathematics, Informatics and Mechanics Mikołaj Konarski Application of Category-Theory Methods to the Design of a System of Modules for a Functional Programming Language Supervisor Prof. dr hab. Andrzej Tarlecki Institute of Informatics Warsaw University °c Mikołaj Konarski 2006 Author’s Declaration I declare that I have composed this dissertation myself. Supervisor’s Declaration The dissertation is ready for review. Abstract Module systems embed elements of methodologies, formalisms and tools for programming-in-the-large into programming languages. In our thesis we design a module system, its categorical model and a constructive semantics of the system in the model. The categorical model is simple and general, built using elementary categorical notions, admitting many variants and ex- tensions of the module system. Our module system features programming mechanisms inspired by category theory and enables fine-grained modular programming, as witnessed by the case studies presented. We show how to extend our categorical model with data types express- ible as adjunctions, as well as with (co)inductive constructions and with fully parameterized exponents. We analyze and compare alternative axiom- atizations of the extensions and demonstrate a series of properties concern- ing rewriting of terms denoting morphisms of 2-categories; in particular, the terms expressing general adjunctions. On the basis of the extended model and without introducing recursive types we define the mechanism of mutual dependency among modules, in the form of (co)inductive module construction. The extended module sys- tem contains the essential mechanisms of modular programming, such as type sharing, transparent as well as non-transparent functor application and grouping of related modules. Conventional modular idioms are ex- pressible in new, original ways, enabling modular programming with no headers, no explicit module applications and no global modular errors. ACM Classification Categories and subject descriptors: D.3.3 [Programming Languages]: Lan- guage Constructs and Features—Modules, packages; D.2.2 [Software En- gineering]: Design Tools and Techniques—Modules and interfaces; F.4.1 [Mathematical Logic and Formal Languages]: Mathematical Logic— Lambda calculus and related systems; D.1.1 [Programming Techniques]: Applicative (Functional) Programming. Additional key words and phrases: category theory, adjunctions, inductive types, recursive modules, inductive modules, type sharing. Streszczenie Systemy modułów wbudowują do wewnątrz samych języków programo- wania elementy metodologii, formalizmów i narzędzi, służących programo- waniu w dużej skali. W naszej rozprawie projektujemy taki system modu- łów, jego kategoryjny model i konstruktywną semantykę owego systemu w tym modelu. Nasz kategoryjny model jest prosty i ogólny, zbudowany uży- wając elementarnych pojęć teorii kategorii, dopuszczający wiele wariantów i rozszerzeń systemu modułów. Zaprojektowany system modułów charak- teryzuje się mechanizmami programistycznymi inspirowanymi przez teorię kategorii i umożliwia drobnoziarniste programowanie modularne, jak świad- czą zaprezentowane eksperymenty z jego użyciem. Pokazujemy, jak rozszerzyć nasz kategoryjny model o typy danych wyrażalne jako sprzężenia w 2-kategoriach, jak również o konstrukcje (ko)indukcyjne i w pełni sparametryzowane obiekty wykładnicze. Anali- zujemy i porównujemy alternatywne aksjomatyzacje tych rozszerzeń i po- kazujemy szereg własności przepisywania termów oznaczających morfizmy 2-kategorii; w szczególności termów wyrażających ogólne sprzężenia. Na podstawie rozszerzonego modelu i bez wprowadzania rekurencyjnych typów definiujemy mechanizm wzajemnej zależności pomiędzy modułami w postaci konstrukcji (ko)indukcyjnego modułu. Rozszerzony system modu- łów zawiera zasadnicze mechanizmy modularnego programowania, takie jak dzielenie typów, przezroczystą jak i nieprzezroczystą aplikację funktorów oraz grupowanie powiązanych modułów. Popularne modułowe konstruk- cje są wyrażalne na nowe i oryginalne sposoby, umożliwiając modularne programowanie bez nagłówków, bez aplikacji modułów i bez globalnych modułowych błędów. Contents I Introduction 11 1 Overview 12 1.1 Aim and Results ........................... 12 1.2 Previous work ............................. 17 1.2.1 Module systems ........................ 17 1.2.2 Models of module systems . 19 1.2.3 Categorical models of core language . 19 1.2.4 Term rewriting ........................ 21 1.3 Summary of the thesis ........................ 22 2 Dule tutorial 30 2.1 Core language mechanisms ...................... 30 2.1.1 Identity and types ...................... 32 2.1.2 Basic value operations .................... 34 2.1.3 Functions and derived forms . 45 2.2 Simple modular programming .................... 51 2.2.1 Base modules ......................... 51 2.2.2 Linking ............................ 55 2.3 Advanced modular programming . 59 2.3.1 Specifications ......................... 59 2.3.2 Module operations ...................... 61 2.3.3 Recursive modules ...................... 71 2.4 Conclusion ............................... 77 2.4.1 Absence of standard mechanisms . 78 2.4.2 Additional ways of expressing . 80 2.4.3 New expressible entities ................... 83 3 Preliminaries 86 3.1 Prerequisites .............................. 86 3.2 Formal notation ............................ 87 3.3 Typical identifiers ........................... 94 6 CONTENTS II Semantics of Dule 97 4 Base categorical model 98 4.1 LC — Labeled Cartesian category . 98 4.1.1 Definition ........................... 98 4.1.2 Language ........................... 99 4.2 2-LC — 2-Labeled Cartesian category . 102 4.2.1 Definition based on LC . 102 4.2.2 Language . 103 4.3 2-LC-lc — 2-LC with labeled products . 105 4.3.1 Definition based on 2-LC . 105 4.3.2 Language . 107 4.4 Conclusion ...............................109 5 Semantics of the module system 112 5.1 Simple Category of Modules . 113 5.1.1 Objects and morphisms . 113 5.1.2 Identity and composition . 118 5.1.3 Products ............................121 5.1.4 Equalizers . 123 5.1.5 Conclusion . 130 5.2 W-Dule — module system with specialization . 130 5.2.1 Language . 131 5.2.2 Algebra of modules . 134 5.2.3 Incorporating core language . 137 5.2.4 Cartesian structure . 144 5.2.5 Specialization, instantiation and trimming . 158 5.2.6 Conclusion . 171 5.3 L-Dule — module system with linking . 172 5.3.1 Language . 172 5.3.2 Grouping . 174 5.3.3 Linking ............................177 5.3.4 Conclusion . 180 6 Instances of the base categorical model 182 6.1 p-Core — core language with product type . 183 6.1.1 Syntactic sugar for indexed lists . 183 6.1.2 Rewriting in LC . 185 6.1.3 Equality testing in LC . 189 6.1.4 Rewriting in 2-LC . 193 6.1.5 Rewriting in 2-LC-lc . 199 6.1.6 Conclusion . 203 CONTENTS 7 6.2 s-Core — core language with sum type . 204 6.2.1 Definition based on p-Core . 204 6.2.2 Language . 205 6.2.3 Rewriting . 207 6.2.4 Conclusion . 213 6.3 i-Core — core language with (co)inductive types . 213 6.3.1 Definition based on s-Core . 214 6.3.2 Language . 214 6.3.3 Rewriting . 218 6.3.4 Conclusion . 228 III Variants and extensions 229 7 Variants of the base categorical model 230 7.1 Adjunctions ..............................230 7.1.1 2-LC-A — 2-LC with adjunctions . 230 7.1.2 2-LC-F — 2-LC-A by factorizers . 235 7.1.3 Example adjunctions . 237 7.1.4 Reduction in 2-LC-F . 244 7.1.5 Conclusion . 250 7.2 Opposite categories . 250 7.2.1 2-LCO — 2-LC with opposite categories . 251 7.2.2 Why exponent is contravariant . 254 7.2.3 Attempt to accommodate parameterized adjoints . 256 7.2.4 2-LCX — 2-LCO with self-dualities . 257 7.2.5 Conclusion . 270 7.3 Parameterized adjunctions . 271 7.3.1 2-LCO-A — 2-LCO with opposite adjunctions . 271 7.3.2 2-LCX-A — 2-LCX with adjunctions . 274 7.3.3 2-LCX-F — 2-LCX-A by factorizers . 287 7.3.4 Reduction in 2-LCX-F . 291 7.3.5 Conclusion . 297 8 Extensions to the core language 298 8.1 e-Core — core language with parameterized exponent . 298 8.1.1 Definition based on i-Core and 2-LCX-F . 298 8.1.2 Language . 299 8.1.3 Construction using 2-LCX-F . 300 8.1.4 Moving back to 2-LC-lc . 306 8.1.5 Conclusion . 308 8.2 f-Core — core language with general recursion . 309 8 CONTENTS 8.2.1 Language . 309 8.2.2 Rewriting . 310 8.2.3 Conclusion . 313 8.3 Extended notation for the core language . 315 8.3.1 Bare core language . 315 8.3.2 User core language . 331 8.3.3 Conclusion . 335 9 Extensions to the module language 336 9.1 I-Dule — module system with inductive modules . 336 9.1.1 Language . 337 9.1.2 Simple inductive modules . 339 9.1.3 Conclusion . 348 9.2 Extended notation for modules . 349 9.2.1 Bare module language . 349 9.2.2 Completeness of module typing . 361 9.2.3 Environment-dependent module language . 367 9.2.4 User module language . 374 9.2.5 Conclusion . 377 IV Conclusion 379 10 Final remarks 380 10.1 Theory .................................380 10.2 Pragmatics ..............................382 10.3 Implementation ............................384 10.4 Type reconstruction algorithms . 385 V Appendices 387 A Language summaries 388 A.1 Internal core language . 388 A.1.1 Syntax .............................388 A.1.2 Semantics . 391 A.1.3 Typing rules . 396 A.1.4 Reduction . 400 A.1.5 Equality testing . 404 A.2 Internal module language . 406 A.2.1 Syntax .............................406 A.2.2 Semantics . 407 CONTENTS 9 A.2.3 Typing rules . 409 A.2.4 Simulation of multiplication . 411 A.2.5 Specification stripping . 413 A.3 Syntax of the full user language . 414 B Longer proofs from Chapter 6 and Chapter 7 417 B.1 Proofs for Chapter 6 . 417 B.2 Proofs for Chapter 7 . 433 C Program examples in Dule 442 C.1 Standard prelude . 442 C.1.1 Module of natural numbers . 443 C.1.2 Module of character strings . 445 C.2 Dule compiler written in Dule . 449 C.2.1 Assigning categories to functors .
Load more

Recommended publications
  • By Joseph Ray Davidson
    AN INFORMATION THEORETIC APPROACH TO THE EXPRESSIVENESS OF PROGRAMMING LANGUAGES by Joseph Ray Davidson Submitted in fulfilment of the requirements for the degree of Doctor of Philosophy University of Glasgow College of Science and Engineering School of Computing Science July 2015 The copyright in this thesis is owned by the author. Any quotation from the thesis or use of any of the information contained in it must acknowledge this thesis as the source of the quotation or information. Abstract The conciseness conjecture is a longstanding notion in computer science that programming languages with more built-in operators, that is more expressive languages with larger semantics, produce smaller programs on average. Chaitin defines the related concept of an elegant program such that there is no smaller program in some language which, when run, produces the same output. This thesis investigates the conciseness conjecture in an empirical manner. Influenced by the concept of elegant programs, we investigate several models of computation, and implement a set of functions in each programming model. The programming models are Turing Machines, λ-Calculus, SKI, RASP, RASP2, and RASP3. The information content of the programs and models are measured as characters. They are compared to investigate hypotheses relating to how the mean program size changes as the size of the semantics change, and how the relationship of mean program sizes between two models compares to that between the sizes of their semantics. We show that the amount of information present in models of the same paradigm, or model family, is a good indication of relative expressivity and aver- age program size.
    [Show full text]
  • Enriched Lawvere Theories for Operational Semantics
    Enriched Lawvere Theories for Operational Semantics John C. Baez and Christian Williams Department of Mathematics U. C. Riverside Riverside, CA 92521 USA [email protected], [email protected] Enriched Lawvere theories are a generalization of Lawvere theories that allow us to describe the operational semantics of formal systems. For example, a graph-enriched Lawvere theory describes structures that have a graph of operations of each arity, where the vertices are operations and the edges are rewrites between operations. Enriched theories can be used to equip systems with oper- ational semantics, and maps between enriching categories can serve to translate between different forms of operational and denotational semantics. The Grothendieck construction lets us study all models of all enriched theories in all contexts in a single category. We illustrate these ideas with the SKI-combinator calculus, a variable-free version of the lambda calculus. 1 Introduction Formal systems are not always explicitly connected to how they operate in practice. Lawvere theories [20] are an excellent formalism for describing algebraic structures obeying equational laws, but they do not specify how to compute in such a structure, for example taking a complex expression and simplify- ing it using rewrite rules. Recall that a Lawvere theory is a category with finite products T generated by a single object t, for “type”, and morphisms tn ! t representing n-ary operations, with commutative diagrams specifying equations. There is a theory for groups, a theory for rings, and so on. We can spec- ify algebraic structures of a given kind in some category C with finite products by a product-preserving functor m : T ! C.
    [Show full text]
  • Proofs As Cryptography: a New Interpretation of the Curry-Howard Isomorphism for Software Certificates Amrit Kumar, Pierre-Alain Fouque, Thomas Genet, Mehdi Tibouchi
    Proofs as Cryptography: a new interpretation of the Curry-Howard isomorphism for software certificates Amrit Kumar, Pierre-Alain Fouque, Thomas Genet, Mehdi Tibouchi To cite this version: Amrit Kumar, Pierre-Alain Fouque, Thomas Genet, Mehdi Tibouchi. Proofs as Cryptography: a new interpretation of the Curry-Howard isomorphism for software certificates. 2012. hal-00715726 HAL Id: hal-00715726 https://hal.archives-ouvertes.fr/hal-00715726 Preprint submitted on 9 Jul 2012 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Proofs as Cryptography: a new interpretation of the Curry-Howard isomorphism for software certificates K. Amrit 1, P.-A. Fouque 2, T. Genet 3 and M. Tibouchi 4 Abstract The objective of the study is to provide a way to delegate a proof of a property to a possibly untrusted agent and have a small certificate guaranteeing that the proof has been done by this (untrusted) agent. The key principle is to see a property as an encryption key and its proof as the related decryption key. The protocol then only consists of sending a nonce ciphered by the property. If the untrusted agent can prove the property then he has the corresponding proof term (λ-term) and is thus able to decrypt the nonce in clear.
    [Show full text]
  • Download (2MB)
    Urlea, Cristian (2021) Optimal program variant generation for hybrid manycore systems. PhD thesis. http://theses.gla.ac.uk/81928/ Copyright and moral rights for this work are retained by the author A copy can be downloaded for personal non-commercial research or study, without prior permission or charge This work cannot be reproduced or quoted extensively from without first obtaining permission in writing from the author The content must not be changed in any way or sold commercially in any format or medium without the formal permission of the author When referring to this work, full bibliographic details including the author, title, awarding institution and date of the thesis must be given Enlighten: Theses https://theses.gla.ac.uk/ [email protected] Optimal program variant generation for hybrid manycore systems Cristian Urlea Submitted in fulfilment of the requirements for the Degree of Doctor of Philosophy School of Engineering College of Science and Engineering University of Glasgow January 2021 Abstract Field Programmable Gate Arrays (FPGAs) promise to deliver superior energy efficiency in het- erogeneous high performance computing (HPC), as compared to multicore CPUs and GPUs. The rate of adoption is however hampered by the relative difficulty of programming FPGAs. High-level synthesis tools such as Xilinx Vivado, Altera OpenCL or Intel’s HLS address a large part of the programmability issue by synthesizing a Hardware Description Languages (HDL) representation from a high-level specification of the application, given in programming lan- guages such as OpenCL C, typically used to program CPUs and GPUs. Although HLS solutions make programming easier, they fail to also lighten the burden of optimization.
    [Show full text]
  • Visualizing the Turing Tarpit
    Visualizing the Turing Tarpit Jason Hemann Eric Holk Indiana University {jhemann,eholk}@cs.indiana.edu Abstract In this paper we begin by refreshing some of the the- Minimalist programming languages like Jot have limited in- ory behind this work, including the λ-calculus and its var- terest outside of the community of languages enthusiasts. ious reduction strategies, universal combinators and their This is a shame, as the simplicity of these languages as- application to languages like Iota and Jot (Section 2). Using cribes to them an inherent beauty and provides deep in- this, we devise several strategies for plotting the behavior of sight into the nature of computation. We present a fun way large numbers of Jot programs (Section 3). We make several of visualizing the behavior of many Jot programs at once, observations about the resulting visualizations (Section 4), providing interesting images and also hinting at somewhat describe related work in the field (Section 5), and suggest non-obvious relationships between programs. In the same possibilities for future work (Section 6). way that research into fractals yielded new mathematical insights, visualizations such as those presented here could yield new insights into the structure and nature of compu- tation. Categories and Subject Descriptors F.4.1 [Mathemat- ical Logic]: Lambda calculus and related systems; D.2.3 [Coding Tools and Techniques]: Pretty printers General Terms language, visualization Keywords Jot, reduction, tarpit, Iota 1. Introduction A Turing tarpit is a programming language that is Turing complete, but so bereft of features that it is impractical for use in actual programming tasks, often even for those con- sidered trivial in more conventional languages.
    [Show full text]
  • Arxiv:1610.02247V3 [Cs.LO] 16 Oct 2016 Aeifrain O Xml,Cnie Hsad Ento Famon a of Definition Agda “Interface This an Consider Or Most Example, “Module” [7]
    Logic as a distributive law Michael Stay1 and L.G. Meredith2 1 Pyrofex Corp. [email protected] 2 Synereo, Ltd [email protected] Abstract. We present an algorithm for deriving a spatial-behavioral type system from a formal presentation of a computational calculus. Given a 2-monad Calc : Cat → Cat for the free calculus on a category of terms and rewrites and a 2-monad BoolAlg for the free Boolean algebra on a category, we get a 2-monad Form = BoolAlg + Calc for the free category of formulae and proofs. We also get the 2-monad BoolAlg ◦Calc for subsets of terms. The interpretation of formulae is a natural transformation J−K: Form ⇒ BoolAlg◦Calc defined by the units and multiplications of the monads and a distributive law transformation δ : Calc ◦ BoolAlg ⇒ BoolAlg ◦ Calc. This interpretation is consistent both with the Curry-Howard isomor- phism and with realizability. We give an implementation of the “possibly” modal operator parametrized by a two-hole term context and show that, surprisingly, the arrow type constructor in the λ-calculus is a specific case. We also exhibit nontrivial formulae encoding confinement and liveness properties for a reflective higher-order variant of the π-calculus. 1 Introduction Sylvester coined the term “universal algebra” to describe the idea of expressing a mathematical structure as set equipped with functions satisfying equations; the idea itself was first developed by Hamilton and de Morgan [7]. Most modern programming languages have a notion of a “module” or an “interface” with this arXiv:1610.02247v3 [cs.LO] 16 Oct 2016 same information; for example, consider this Agda definition of a monoid.
    [Show full text]
  • Download/Pdf/81105779.Pdf
    UC Riverside UC Riverside Previously Published Works Title Enriched Lawvere Theories for Operational Semantics Permalink https://escholarship.org/uc/item/3fz1k4k1 Authors Baez, John C Williams, Christian Publication Date 2020-09-15 DOI 10.4204/eptcs.323.8 Peer reviewed eScholarship.org Powered by the California Digital Library University of California Enriched Lawvere Theories for Operational Semantics John C. Baez and Christian Williams Department of Mathematics U. C. Riverside Riverside, CA 92521 USA [email protected], [email protected] Enriched Lawvere theories are a generalization of Lawvere theories that allow us to describe the operational semantics of formal systems. For example, a graph-enriched Lawvere theory describes structures that have a graph of operations of each arity, where the vertices are operations and the edges are rewrites between operations. Enriched theories can be used to equip systems with oper- ational semantics, and maps between enriching categories can serve to translate between different forms of operational and denotational semantics. The Grothendieck construction lets us study all models of all enriched theories in all contexts in a single category. We illustrate these ideas with the SKI-combinator calculus, a variable-free version of the lambda calculus. 1 Introduction Formal systems are not always explicitly connected to how they operate in practice. Lawvere theories [20] are an excellent formalism for describing algebraic structures obeying equational laws, but they do not specify how to compute in such a structure, for example taking a complex expression and simplify- ing it using rewrite rules. Recall that a Lawvere theory is a category with finite products T generated by a single object t, for “type”, and morphisms tn ! t representing n-ary operations, with commutative diagrams specifying equations.
    [Show full text]
  • Enriched Lawvere Theories for Operational Semantics
    ENRICHED LAWVERE THEORIES FOR OPERATIONAL SEMANTICS John C. Baez Department of Mathematics University of California Riverside CA, USA 92521 and Centre for Quantum Technologies National University of Singapore Singapore 117543 Christian Williams Department of Mathematics University of California Riverside CA, USA 92521 email: [email protected], [email protected] September 4, 2019 Abstract. Enriched Lawvere theories are a generalization of Lawvere theories that allow us to describe the operational semantics of formal systems. For example, a graph-enriched Lawvere theory describes structures that have a graph of operations of each arity, where the vertices are operations and the edges are rewrites between operations. Enriched theories can be used to equip systems with operational semantics, and maps between enriching categories can serve to translate between different forms of operational and denotational semantics. The Grothendieck construction lets us study all models of all enriched theories in all contexts in a single category. We illustrate these ideas with the SKI-combinator calculus, a variable-free version of the lambda calculus, and with Milner's calculus of communicating processes. 1. Introduction Formal systems are not always explicitly connected to how they operate in practice. Lawvere theories [19] are an excellent formalism for describing algebraic structures obeying equational laws, but they do not specify how to compute in such a structure, for example taking a complex expression and simplifying it using rewrite rules. Recall that a Lawvere theory is a category with finite products T generated by a single object t, for \type", and morphisms tn ! t representing n-ary operations, with commutative diagrams specifying equations.
    [Show full text]
  • Verified Translation of a Strongly Typed Functional Language with Variables to a Language of Indexed Gates
    Verified Translation of a Strongly Typed Functional Language with Variables to a Language of Indexed Gates Rob Spoel 2019 Contents 1 Abstract 1 2 Research goal 2 2.1 Preamble .............................. 2 2.2 Research statement ......................... 2 2.3 Contribution ............................. 2 2.4 Scientific relevance ......................... 3 3 Background 4 3.1 Dependently typed programming: Agda .............. 4 3.2 The Curry-Howard isomorphism .................. 4 3.3 Hardware design .......................... 5 3.4 Verified translation ......................... 6 3.5 Embeddings and EDSLs ...................... 7 3.5.1 Variable binding in embedded domain specific languages . 7 3.5.2 Nameless .......................... 7 3.5.3 De Bruijn .......................... 8 3.5.4 HOAS/PHOAS ....................... 8 4 SKI transpiler 10 4.1 Simply-typed 휆-calculus ...................... 10 4.2 SKI combinators .......................... 12 4.3 Translation ............................. 13 4.4 Correctness ............................. 15 5 Π-Ware and Λ1 16 5.1 Π-Ware ............................... 16 5.2 Plugs versus named variables .................... 18 5.3 Λ1 .................................. 18 5.3.1 Type universe ........................ 20 5.3.2 Variable bindings ...................... 22 5.3.3 Gates ............................ 23 6 Translation 24 6.1 Intermediate language ........................ 24 6.2 Atomization of polytypes ...................... 26 6.3 Stage 1 ............................... 28 6.3.1 Translation ........................
    [Show full text]