A List of Successes That Can Change the World Essays Dedicated to Philip Wadler on the Occasion of His 60th Birthday

This volume is published in Honor of PhilipWadler on the occasion of his 60th birthday, and the collection of papers forma Festschrift for him. The contributions are made by some of the many who knowPhil and have been influenced by him. The research papers included hererepresent some of the areas in...

Full description

Saved in:
Bibliographic Details
Main Authors Lindley, Sam, McBride, Conor, Trinder, Phil, Sannella, Don
Format eBook
LanguageEnglish
Published Cham Springer Nature 2016
Springer International Publishing AG
Springer International Publishing
Springer
Edition1
SeriesLecture Notes in Computer Science
Subjects
Computer programming, programs, data
Computer Science
Logics and Meanings of Programs
Mathematical Logic and Formal Languages
Programming Languages, Compilers, Interpreters
Programming Techniques
Software Engineering
Online AccessGet full text
ISBN9783319309361
3319309366
3319309358
9783319309354
ISSN0302-9743
1611-3349
DOI10.1007/978-3-319-30936-1

Cover

Table of Contents:
  • 2.1 Basic Use of Effects -- 2.2 Generativity Polymorphism -- 3 Type System -- 4 Related Work -- 5 Future Work -- A Elaboration -- A.1 Internal Language -- A.2 Encoding Semantic Types -- A.3 Meta-Theory -- References -- The Computer Scientist Nightmare -- 1 A Multitier Bug -- 2 Read, Compile, Print -- 3 The Usual Suspects -- 4 The Solution -- 5 Concluding Remarks -- A Branding Strategy for Business Types -- 1 Introduction -- 2 Overview -- 3 Data and Types -- 3.1 Data Model -- 3.2 Types -- 4 Subtyping and Models -- 4.1 Subtyping -- 4.2 Models -- 4.3 Typed Data -- 5 Operators -- 5.1 Syntax and Semantics -- 5.2 Typing -- 6 Business Rules Compiler -- 6.1 CAMP -- 6.2 NRA -- 6.3 From CAMP to NRA -- 7 Related Work -- 8 Conclusion -- A Operators Semantics -- References -- The Recursive Union of Some Gradual Types -- 1 Introduction -- 2 STLC with Recursive Types and Unions, -- 2.1 Union Types and Case -- 2.2 Equi-Recursive Types -- 2.3 Type System -- 2.4 Operational Semantics -- 3 GTLC with Recursive Types and Unions, -- 3.1 Type System -- 3.2 Algorithmic Type System -- 3.3 Translation to the Blame Calculus via Cast Insertion -- 4 Blame Calculus with Recursive Rypes and Union, B -- 4.1 Example Revisited -- 4.2 Type Safety of B -- 4.3 Blame Safety -- 5 Conclusion -- A Appendix -- A.1 Type Safety of -- A.2 Correctness of Algorithmic Type System for -- A.3 Translation to B Preserves Types -- A.4 Type Safety of B -- A.5 Blame Safety -- References -- A Delta for Hybrid Type Checking -- 1 Introduction -- 2 The Hybrid Blame Calculus -- 2.1 Syntax and Dynamics -- 2.2 Statics -- 3 The Hybrid Coercion Calculus -- 3.1 Syntax and Dynamics -- 3.2 Statics -- 4 Translations -- 5 Results -- 6 A Concrete Instance -- 7 More Manifestation -- 8 Related Work -- A Proofs -- A.1 Preservation for hb -- A.2 Preservation for hc -- References
  • Certifying Data in Multiparty Session Types
  • Intro -- Preface -- References -- Contents -- Reflections on Monadic Lenses -- 1 Introduction -- 2 Asymmetric Monadic Lenses -- 2.1 A Naive Approach -- 2.2 Monadic Put-Lenses -- 2.3 Monadic Lenses -- 3 Symmetric Monadic Lenses and Spans -- 3.1 Naive Monadic Symmetric Lenses -- 3.2 Entangled State Monads -- 3.3 Spans of Monadic Lenses -- 4 Equivalence of Spans -- 5 Conclusions -- A Proofs for Sect.2 -- B Proofs for Sect.3 -- C Proofs for Sect.4 -- References -- Conflation Confers Concurrency -- 1 Introduction -- 2 Background -- 3 Classical Linear Logic and the Process Calculus CP -- 3.1 Types and Duality -- 3.2 Terms and Typing -- 3.3 Semantics via Cut Reduction -- 4 Conflating Duals -- 4.1 Concurrency Without Communication (1 and ) -- 4.2 Concurrency with Multiple Channels ( and ) -- 4.3 Nondeterminism (0 and / and &amp -- ) -- 4.4 Access Points (! and ?) -- 5 Conclusions and Future Work -- References -- Counting Successes: Effects and Transformations for Non-deterministic Programs -- 1 Introduction -- 2 Effects for Non-determinism -- 2.1 Base Language -- 2.2 Effect System -- 2.3 Semantics of Effects -- 2.4 Basic Equations -- 3 Using Effect Information -- 4 Discussion -- References -- The Essence of Inheritance -- 1 Introduction -- 2 Interpreting Inheritance -- 2.1 Variation Minus One: Object-Oriented Evaluation -- 2.2 What is a Monad? -- 2.3 Variation Zero: Monadic Evaluation -- 2.4 Variation One: Evaluation with Exceptions -- 2.5 Variation Three: Propagating State -- 2.6 Variation Four: Output -- 3 The Erlang OTP Platform -- 3.1 Armstrong's Goal -- 3.2 The Basic Server -- 3.3 Adding Transactions -- 3.4 The Hot-Swap Server -- 3.5 Summary -- 4 Discussion and Conclusion -- 4.1 From the Abstract to the Concrete -- 4.2 What About Types? -- 4.3 Further Extensions -- 4.4 Conclusion -- References -- Subtyping Supports Safe Session Substitution
  • 1.1 Lambda Calculus Defined -- 2 Conclusion and Further Work -- References -- I Got Plenty o' Nuttin' -- 1 Introduction -- 2 A Rig of Resources -- 3 Syntax and Computation -- 4 Typing Rules -- 5 Dependent Iterative Demolition of Lists -- 6 Confluence of Computation -- 7 Subtyping and Its Metatheory -- 8 Not That Kind of Module System -- 9 Resourced Stability Under Substitution -- 10 Computation Preserves Typing -- 11 Erasure to an Implicit Calculus -- 12 Take It or Leave It -- 13 Contemplation -- References -- Pointlessness is Better than Listlessness -- 1 Introduction -- 2 Shall I Be Pure? -- 3 Transforming Programs to Eliminate Trees -- 4 Calculating is Better than Scheming -- 4.1 Deriving Circuit Combinators -- 4.2 Deriving Effect on State of Array Operations -- 5 A New Array Operation: Performance on a GPU -- 5.1 Bulk Updates -- 5.2 Searches -- 5.3 Long Arrays Created Using Updates -- 5.4 Long Arrays with Deletes for Intermediate Arrays -- 6 Fixing Some Space Leaks with a Hardware Garbage Collector -- 7 Conclusion -- References -- The Essence of Dependent Object Types -- 1 Introduction -- 2 System D&lt -- : -- 2.1 Example: Dependent Sums -- 3 Embedding F&lt -- : in D&lt -- : -- 4 DOT -- 4.1 Records -- 4.2 Type Labels -- 4.3 Recursion -- 4.4 Meta-Theory -- 5 Encodings -- 5.1 Abbreviations -- 5.2 Example: A Covariant Lists Package -- 6 Dependent Types in Scala -- 7 Implementation -- 8 Related Work -- 9 Conclusion and Future Work -- A Additional Rules and Detailed Proofs -- A.1 Typing of Dependent Sums/s -- A.2 Proof of Theorem2 -- References -- Linear is CP (more or less) -- 1 Introduction -- 2 CP and Session Types -- 2.1 Syntax and Static Semantics -- 2.2 Operational Semantics -- 2.3 Reduction and Equivalence -- 3 Linear and Linear Classical Logic -- 3.1 Syntax and Static Semantics -- 3.2 Operational Semantics -- 4 Dualization and CP
  • 4.1 Duality in -- 4.2 Polarizing CP -- 4.3 Evaluation Order -- 5 Equational Correspondence -- 6 Discussion -- 6.1 Comparing Classical Type Systems -- 6.2 A Syntax for Tensor Logic -- 6.3 Session Types and Linear Logic -- 6.4 Variations on CP -- 6.5 How Much is ``More or Less''? -- References -- A Reflection on Types -- 1 Preface -- 2 Introduction -- 3 Dynamic Types in a Statically Typed Language -- 4 The Challenge of an Open World -- 5 TypeRep: Runtime Reflection in an Open World -- 5.1 Introducing TypeRep -- 5.2 The Typeable Class -- 5.3 Type-Aware Equality for TypeReps -- 5.4 Decomposing Type Representations -- 5.5 Kind Polymorphism and Kind Equalities -- 5.6 Visible vs. Invisible Type Representations -- 5.7 Comparing TypeReps -- 5.8 Representing Polymorphic and Kind-Polymorphic Types -- 5.9 Summary -- 6 Implementation -- 7 Properties of a Language with Reflection -- 8 Other Applications of TypeRep and dynamic -- 8.1 Variants of Dynamic -- 8.2 Supporting Generic Programming -- 8.3 Distributed Programming and Persistence -- 8.4 Meta Programming -- 9 Related Work -- 9.1 The Old Implementation of Typeable and Dynamic -- 9.2 Dynamics in a Closed World -- 9.3 Dynamic Typing in Other Statically-Typed Languages -- 9.4 Reflection in Java -- 9.5 Generic Programming and Type Representations -- 10 Conclusions and Further Work -- References -- The Essence of Multi-stage Evaluation in LMS -- 1 Introduction -- 2 A Two-Stage Lambda Calculus -- 3 Single-Stage Evaluation -- 4 ANF Conversion/Let-Insertion -- 5 Multi-stage Evaluation -- 6 Recursion -- 7 Relation to LMS -- 8 Case Study: Regular Expression Matchers -- 8.1 Regexp Matchers as Nondeterministic Finite Automata (NFA) -- 8.2 From NFA to DFA Using Staging -- 8.3 Generated State Machine Code -- 9 Related Work -- References -- 1ML with Special Effects -- 1 Introduction -- 2 The Language
  • 1 Prologue -- 2 Introduction -- 3 Session Types and Subtyping -- 4 Channel-Oriented Subtyping -- 4.1 Safe Substitutability of Channels, Formally -- 4.2 Channel-Oriented Subtyping by Translation -- 4.3 Channel-Oriented Subtyping by Semantic Subtyping -- 5 Process-Oriented Subtyping -- 6 Unifying Channel- and Process-Oriented Subtyping -- 7 Conclusion -- References -- Proof-Relevant Parametricity -- 1 Introduction -- 2 Impredicative Type Theory and the Identity Type -- 3 Proof-Relevant Relations -- 4 Relations Between Relations -- 5 Proof-Relevant Two-Dimensional Parametricity -- 5.1 Interpretation of Types -- 5.2 Interpretation of Terms -- 6 Theorems About Proofs for Free -- 6.1 Graph Relations and Graph 2-Relations -- 6.2 Coherent Proofs of Naturality -- 7 Conclusions and Future Work -- A Proofs from Section5 -- References -- Comprehending Ringads -- 1 Introduction -- 2 Comprehensions -- 2.1 List Comprehensions -- 2.2 Monad Comprehensions -- 2.3 Heterogeneous Comprehensions -- 3 Ringads and Collections -- 3.1 Aggregation -- 3.2 Notes on ``Notes on Monads and Ringads'' -- 4 Comprehending Joins -- 4.1 Parallel Comprehensions -- 4.2 Grouping Comprehensions -- 4.3 Relational Tables -- 4.4 Finite Maps -- 5 Conclusions -- References -- Dragging Proofs Out of Pictures -- 1 Introduction -- 2 Monads and Monad Maps -- 3 Composing Monads -- 4 Compatible Compositions -- 5 Iterated Distributive Laws -- 6 Conclusion -- References -- Experiences with QuickCheck: Testing the Hard Stuff and Staying Sane -- 1 Introduction -- 2 A Simple Example -- 3 The Volvo Project -- 4 Debugging a Database -- 5 In Conclusion -- References -- Cutting Out Continuations -- 1 Introduction -- 2 Arithmetic Expressions -- 3 Fusing the Transformation Steps -- 4 Lambda Calculus -- 5 Summary and Conclusion -- References -- The Lambda Calculus: Practice and Principle -- 1 Introduction