A history of Haskell: being lazy with class

  title={A history of Haskell: being lazy with class},
  author={Paul Hudak and John Hughes and Simon L. Peyton Jones and Philip Wadler},
  journal={Proceedings of the third ACM SIGPLAN conference on History of programming languages},
  • P. Hudak, John Hughes, P. Wadler
  • Published 9 June 2007
  • Economics
  • Proceedings of the third ACM SIGPLAN conference on History of programming languages
This paper describes the history of Haskell, including its genesis and principles, technical contributions, implementations and tools, and applications and impact. 

Figures from this paper

Some History of Functional Programming Languages - (Invited Talk)
  • D. Turner
  • Computer Science
    Trends in Functional Programming
  • 2012
We study a series of milestones leading to the emergence of lazy, higher order, polymorphically typed, purely functional programming languages. An invited lecture given at TFP12, St Andrews
Sneaking around concatMap
We present a framework of dynamic programming combinators that provides a high-level environment to describe the recursions typical of dynamic programming over sequence data in a style very similar...
A play on regular expressions
Cody, Hazel, and Theo, two experienced Haskell programmers and an expert in automata theory, develop an elegant Haskell program for matching regular expressions: (i) the program is purely functiona...
Behaviour-Interaction-Priority in Functional Programming Languages Formalisation and Implementation of Concurrency Frameworks in Haskell and Scala
This paper presents a meta-modelling framework for solving the challenge of integrating NoSQL data stores to manage correlated messages in a graph-based model.
HaGPipe : Programming the graphics pipeline in Haskell
HaGPipe has a clean, purely functional and strongly typed interface and targets the whole graphic programming in Haskell.
Programming in Haskell
This clear-cut text will enable students to write simpler and cleaner code, and to learn how to structure and reason about programs.
A Portable, Simple, Embeddable Type System
A simple type system inspired by that of Common Lisp is presented, intended to be embedded into a host language and accepts certain fundamental types from that language as axiomatically given.
Haskell Dynamic Tracing
This work develops a tool for dynamic analysis used to trace the evaluation of function parameters and is implemented as a compiler plugin for the Glasgow Haskell Compiler.
Lightweight Higher-Kinded Polymorphism
Higher-kinded polymorphism —i.e. abstraction over type constructors— is an essential component of many functional programming techniques such as monads, folds, and embedded DSLs. ML-family languages
Trees that Grow
A programming idiom that exploits type-level functions to allow a particular form of extensibility in functional data types is described, which scales to support existentials and generalised algebraic data types.


A lazy evaluator
A different way to execute pure LISP programs is presented. It delays the evaluation of parameters and list structures without ever having to perform more evaluation steps than the usual method.
The Glasgow Haskell Compiler: a technical overview
An overview of the Glasgow Haskell compiler is given, focusing especially on way in which the compiler has been able to exploit the rich theory of functional languages to give very practical improvements in the compiler.
A short cut to deforestation
This work proposes an automatic technique for improving theiency of programs, by removing many of these intermediate lists, based on a single, simple, local transformation.
Deforestation: Transforming Programs to Eliminate Trees
  • P. Wadler
  • Computer Science
    Theor. Comput. Sci.
  • 1990
An Overview of the Scala Programming Language
This paper gives an overview of the Scala language for readers who are familar with programming methods and programming language design.
Tracing Lazy Functional Computations Using Redex Trails
The basis of the tracing method is a program transformation carried out by the compiler: transformed programs compute the same values as the original, but embedded in functional data structures that also include redex trails showing how the values were obtained.
A compiler for lazy ML
LML is a strongly typed, statically scoped functional Language with Lazy evaluation. It is compiled trough a number of program transformations which makes the code generation easier. Code is
A Practical Data Flow Computer
Based on a tagged dynamic data flow model, this prototype machine has eight unusual matching functions for handling incoming data tokens at its computational nodes. 10 references.
Some practical methods for rapid combinator reduction
Details of some of the more novel methods employed by SKIM II are given, and it is concluded that combinator reduction can still form the basis for the efficient implementation of a functional language.
Revised4 report on the algorithmic language scheme
The report gives a defining description of the programming language Scheme. Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language invented by Guy Lewis