Functional Programming with Overloading and Higher-Order Polymorphism

The Hindley/Milner type system has been widely adopted as a basis for statically typed functional languages. One of the main reasons for this is that it provides an elegant compromise between flexibility, allowing a single value to be used in different ways, and practicality, freeing the programmer from the need to supply explicit type information. Focusing on practical applications rather than implementation or theoretical details, these notes examine a range of extensions that provide more flexible type systems while retaining many of the properties that have made the original Hindley/Milner system so popular. The topics discussed, some old, but most quite recent, include higher-order polymorphism and type and constructor class overloading. Particular emphasis is placed on the use of these features to promote modularity and reusability.

[1]  R. Hindley.  The Principal Type-Scheme of an Object in Combinatory Logic , 1969 .

[2]  Robin Milner,et al.  A Theory of Type Polymorphism in Programming , 1978, J. Comput. Syst. Sci..

[3]  Rod M. Burstall,et al.  HOPE: An experimental applicative language , 1980, LISP Conference.

[4]  K. Brown,et al.  Graduate Texts in Mathematics , 1982 .

[5]  Robin Milner,et al.  Principal type-schemes for functional programs , 1982, POPL '82.

[6]  David Turner.  An overview of Miranda , 1986, SIGP.

[7]  Richard S. Bird,et al.  Introduction to functional programming , 1988, Prentice Hall International series in computer science.

[8]  S. K. Park,et al.  Random number generators: good ones are hard to find , 1988, CACM.

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

[10]  Eugenio Moggi,et al.  Computational lambda-calculus and monads , 1989, [1989] Proceedings. Fourth Annual Symposium on Logic in Computer Science.

[11]  Robin Milner,et al.  Definition of standard ML , 1990 .

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

[13]  David Turner.  An overview of Miranda 1 , 1990 .

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

[15]  D. Turner.  Duality and De Morgan principles for lists , 1990 .

[16]  Maarten M. Fokkinga,et al.  Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire , 1991, FPCA.

[17]  Mark P. Jones.  Computing with Lattices: An Application of Type Classes , 1992, J. Funct. Program..

[18]  Philip Wadler,et al.  Combining Monads , 1992 .

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

[20]  Simon L. Peyton Jones,et al.  Report on the programming language Haskell: a non-strict, purely functional language version 1.2 , 1992, SIGP.

[21]  Mark P. Jones.  A system of constructor classes: overloading and implicit higher-order polymorphism , 1993, FPCA '93.

[22]  Jeremy Gibbons,et al.  Linear−time Breadth−first Tree Algorithms: An Exercise in the Arithmetic of Folds and Zips , 1993 .

[23]  David Espinosa.  Building Interpreters by Transforming Stratified Monads , 1994 .

[24]  Mark P. Jones,et al.  The implementation of the Gofer functional programming system , 1994 .

[25]  Guy L. Steele,et al.  Building interpreters by composing monads , 1994, POPL '94.

[26]  Mark P. Jones.  Dictionary-free overloading by partial evaluation , 1995, LISP Symb. Comput..

[27]  Paul Hudak,et al.  Monad transformers and modular interpreters , 1995, POPL '95.

[28]  Mark P. Jones,et al.  A system of constructor classes: overloading and implicit higher-order polymorphism , 1993, FPCA '93.

[29]  Paul Hudak,et al.  Modular Denotational Semantics for Compiler Construction , 1996, ESOP.

[30]  Philip Wadler,et al.  The essence of functional programming (Invited talk) , 1997 .