Trends in Functional Programming

This book presents latest research developments in the area of functional programming. The contributions, in this volume, cover a wide range of topics from theory, formal aspects of functional programming, graphics and visual programming to distributed computing and compiler design. As is often the case in this community, the most prolific work comes out of the combination of theoretical work with its application on classical problems in computer science. Particular trends in this volume are: reasoning about functional programs; automated theorem proving for high-level programming languages; and, language support for concurrency and distribution. The "TFP" series is dedicated to promoting new research directions related to the field of functional programming and to investigate the relationships of functional programming with other branches of computer science. It is designed to be a platform for novel and upcoming research.

[1]  Marko C. J. D. van Eekelen,et al.  Proof Tool Support for Explicit Strictness , 2005, IFL.

[2]  Richard B. Kieburtz,et al.  P-logic: property verification for Haskell programs , 2002 .

[3]  Simon L. Peyton Jones,et al.  HsDebug: debugging lazy programs by not being lazy , 2003, Haskell '03.

[4]  Nate Foster,et al.  Combinators for bi-directional tree transformations: a linguistic approach to the view update problem , 2005, POPL '05.

[5]  Janis Voigtländer,et al.  Concatenate, reverse and map vanish for free , 2002, ICFP '02.

[6]  Andreas Rossberg,et al.  Generativity and dynamic opacity for abstract types , 2003, PPDP '03.

[7]  Olivier Danvy,et al.  From Interpreter to Compiler and Virtual Machine: A Functional Derivation , 2003 .

[8]  Patricia Johann A Generalization of Short-Cut Fusion and its Correctness Proof , 2002, High. Order Symb. Comput..

[9]  Andrew John Gill,et al.  Cheap deforestation for non-strict functional languages , 1996 .

[10]  Olivier Danvy,et al.  A functional correspondence between evaluators and abstract machines , 2003, PPDP '03.

[11]  John C. Reynolds,et al.  Definitional Interpreters for Higher-Order Programming Languages , 1972, ACM '72.

[12]  Matthieu Sozeau,et al.  First-Class Type Classes , 2008, TPHOLs.

[13]  M. Lillibridge Translucent Sums: A Foundation for Higher-Order Module Systems , 1997 .

[14]  Peter Thiemann,et al.  WASH/CGI: Server-Side Web Scripting with Sessions and Typed, Compositional Forms , 2002, PADL.

[15]  Viktor Vafeiadis,et al.  Acute: high-level programming language design for distributed computation , 2005, ICFP '05.

[16]  Koen Claessen,et al.  QuickCheck: a lightweight tool for random testing of Haskell programs , 2011, SIGP.

[17]  Keith Hanna,et al.  Interactive visual functional programming , 2002, ICFP '02.

[18]  Joe Armstrong,et al.  Concurrent programming in ERLANG , 1993 .

[19]  Peter Van Roy,et al.  Concepts, Techniques, and Models of Computer Programming , 2004 .

[20]  Nick Benton,et al.  Some Domain Theory and Denotational Semantics in Coq , 2009, TPHOLs.

[21]  Akihiko Takano,et al.  Shortcut deforestation in calculational form , 1995, FPCA '95.

[22]  David B. MacQueen,et al.  The Definition of Standard ML (Revised) , 1997 .

[23]  Xavier Leroy,et al.  Applicative functors and fully transparent higher-order modules , 1995, POPL '95.

[24]  Till Mossakowski,et al.  HasCasl: Integrated higher-order specification and program development , 2009, Theor. Comput. Sci..

[25]  Koji Kagawa Compositional references for stateful functional programming , 1997, ICFP '97.

[26]  D. A. Turner,et al.  Miranda: A Non-Strict Functional language with Polymorphic Types , 1985, FPCA.

[27]  Colin Runciman,et al.  Smallcheck and lazy smallcheck: automatic exhaustive testing for small values , 2008, Haskell '08.

[28]  Aleksandar Nanevski,et al.  Ynot : Reasoning with the Awkward Squad , 2008 .

[29]  Peyton Jones,et al.  Haskell 98 language and libraries : the revised report , 2003 .

[30]  Stephen Travis Pope,et al.  A cookbook for using the model-view controller user interface paradigm in Smalltalk-80 , 1988 .

[31]  Christine Paulin-Mohring,et al.  The coq proof assistant reference manual , 2000 .

[32]  John Launchbury,et al.  Warm fusion: deriving build-catas from recursive definitions , 1995, FPCA '95.

[33]  Joel Kelso,et al.  A visual programming environment for functional languages , 2002 .

[34]  Philip Wadler,et al.  The essence of functional programming , 1992, POPL '92.

[35]  Olivier Danvy,et al.  Defunctionalization at work , 2001, PPDP '01.

[36]  Leif Kornstaedt,et al.  A Virtual Machine for Multi-Language Execution , 2002 .

[37]  Simon L. Peyton Jones,et al.  Compiling Haskell by Program Transformation: A Report from the Trenches , 1996, ESOP.

[38]  Gérard P. Huet,et al.  The Zipper , 1997, Journal of Functional Programming.

[39]  Andrew Moran,et al.  Improvement in a lazy context: an operational theory for call-by-need , 1999, POPL '99.

[40]  Ralf Hinze,et al.  Just do it: simple monadic equational reasoning , 2011, ICFP.

[41]  Roland Carl Backhouse Program Construction: Calculating Implementations from Specifications , 2003 .

[42]  Dana N. Xu Extended static checking for haskell , 2006, Haskell '06.

[43]  Patricia Johann Short cut fusion is correct , 2003, J. Funct. Program..

[44]  Brian T. Howard Inductive, coinductive, and pointed types , 1996, ICFP '96.

[45]  Andy Gill Introducing the Haskell equational reasoning assistant , 2006, Haskell '06.

[46]  Andrew K. Wright Pattern Matching for Scheme , 2000 .

[47]  Graham Hutton,et al.  Compiling Exceptions Correctly , 2004, MPC.

[48]  J. Michael Spivey,et al.  A Functional Theory of Exceptions , 1990, Sci. Comput. Program..

[49]  John H. Reppy,et al.  Concurrent programming in ML , 1999 .

[50]  Philip Wadler,et al.  Fixing some space leaks with a garbage collector , 1987, Softw. Pract. Exp..

[51]  Olivier Danvy,et al.  A Functional Correspondence between Monadic Evaluators and Abstract Machines for Languages with Computational Effects , 2003 .

[52]  W. Pugh,et al.  A framework for unifying reordering transformations , 1993 .

[53]  Graham Hutton,et al.  A tutorial on the universality and expressiveness of fold , 1999, Journal of Functional Programming.

[54]  Will Partain,et al.  The nofib Benchmark Suite of Haskell Programs , 1992, Functional Programming.

[55]  Eduardo Giménez,et al.  Un calcul de constructions infinies et son application a la verification de systemes communicants , 1996 .

[56]  Simon L. Peyton Jones,et al.  Let-floating: moving bindings to give faster programs , 1996, ICFP '96.

[57]  Hartmut Ehrig,et al.  Handbook of graph grammars and computing by graph transformation: vol. 3: concurrency, parallelism, and distribution , 1999 .

[58]  Alan Mycroft,et al.  The cache behaviour of large lazy functional programs on stock hardware , 2002, MSP/ISMM.

[59]  Phil Trinder,et al.  The Design of Scalable Distributed Erlang , 2012 .

[60]  Sam Tobin-Hochstadt,et al.  Languages as libraries , 2011, PLDI '11.

[61]  Robert H. Halstead,et al.  MULTILISP: a language for concurrent symbolic computation , 1985, TOPL.

[62]  Gert Smolka The Oz Programming Model , 1996 .

[63]  Sam Tobin-Hochstadt,et al.  Extensible Pattern Matching in an Extensible Language , 2011, ArXiv.

[64]  Simon Peyton Jones,et al.  Measuring the effectiveness of a simple strictness analyser , 1993, Functional Programming.

[65]  Lars Birkedal,et al.  Hoare type theory, polymorphism and separation1 , 2008, Journal of Functional Programming.

[66]  Sander Evers Form follows function: Editor GUIs in a functional style , 2004 .

[67]  Tobias Nipkow Compiling Exceptions Correctly , 2004, Arch. Formal Proofs.

[68]  Marko C. J. D. van Eekelen,et al.  Theorem Proving for Functional Programmers , 2001, IFL.

[69]  Tarmo Uustalu,et al.  Build, Augment and Destroy, Universally , 2004, APLAS.

[70]  Philip T. Cox,et al.  Prograph: a step towards liberating programming from textual conditioning , 1989, [Proceedings] 1989 IEEE Workshop on Visual Languages.

[71]  Simon L. Peyton Jones,et al.  A short cut to deforestation , 1993, FPCA '93.

[72]  Tatsuya Hagino,et al.  A Typed Lambda Calculus with Categorical Type Constructors , 1987, Category Theory and Computer Science.

[73]  Claudio V. Russo Types for Modules , 2004, Electronic Notes in Theoretical Computer Science.

[74]  M.C.J.D. van Eekelen,et al.  Proof Support for General Type Classes , 2004 .

[75]  Philip Wadler,et al.  How to make ad-hoc polymorphism less ad hoc , 1989, POPL '89.

[76]  Jack B. Dennis,et al.  First version of a data flow procedure language , 1974, Symposium on Programming.

[77]  Gabriele Taentzer,et al.  The AGG approach: language and environment , 1999 .

[78]  P. J. Landin The Mechanical Evaluation of Expressions , 1964, Comput. J..

[79]  Philip Wadler,et al.  Comprehending monads , 1990, LISP and Functional Programming.

[80]  John C. Reynolds,et al.  Types, Abstraction and Parametric Polymorphism , 1983, IFIP Congress.

[81]  Brian Huffman,et al.  Axiomatic Constructor Classes in Isabelle/HOLCF , 2005, TPHOLs.

[82]  Thomas Hallgren Haskell tools from the programatica project , 2003, Haskell '03.

[83]  Olaf Chitil,et al.  Common Subexpressions Are Uncommon in Lazy Functional Languages , 1997, Implementation of Functional Languages.

[84]  Jan Kuper,et al.  A Functional Programming Technique for Forms in Graphical User Interfaces , 2004, IFL.

[85]  Na Xu Static contract checking for Haskell , 2009, POPL '09.

[86]  Timothy W. Simpson,et al.  Verified programming in Guru , 2009, PLPV '09.

[87]  Matthias Felleisen,et al.  The semantics of future and its use in program optimization , 1995, POPL '95.

[88]  André L. M. Santos,et al.  Compilation by transformation in non-strict functional languages , 1995 .

[89]  Philip Wadler,et al.  Theorems for free! , 1989, FPCA.

[90]  Martín Abadi,et al.  Dynamic typing in polymorphic languages , 1995, Journal of Functional Programming.

[91]  William L. Harrison,et al.  Under Consideration for Publication in J. Functional Programming the Logic of Demand in Haskell , 2022 .