Skip to content

Haskell and Pure Functional Programming

Abstract

Haskell was designed by a committee of researchers who met at a conference in Portland in September 1987 and agreed that more than a dozen similar lazy functional languages were splitting their field. The first Haskell Report appeared on 1 April 1990. The language is purely functional (functions have no side effects) and lazy (nothing is computed until it is needed), and it solved the problem this created for input and output with monads, borrowed from category theory. Its type classes, monadic I/O, property-based testing and software transactional memory spread to other languages (see The Rise of Functional Programming). Haskell itself stayed a minority language used in research, finance, compilers and a few large systems such as Facebook’s spam filter. Its formal standard stopped at Haskell 2010; the compiler GHC became the de facto definition of the language, and in 2026 the community began revising the 2010 report to match it.

Simon Peyton Jones
Simon Peyton Jones, a member of the original Haskell committee and for three decades the lead developer of the Glasgow Haskell Compiler, in 2016. Image: Duncan Hull, CC BY-SA 4.0, via Wikimedia Commons.

The Lazy Tower of Babel

In the early 1980s a group of researchers became convinced that lazy evaluation, computing a value only when it is needed, was the right foundation for programming. It came directly from the lambda calculus, it allowed infinite data structures, and it let programs be built from small, reusable pieces. John Hughes’s paper “Why Functional Programming Matters” (written in 1984 and published in 1989) made the case that laziness gave programmers a new kind of glue for combining modules.

Each research group built its own language to test the idea. The authors of the official history counted more than a dozen non-strict, purely functional languages by 1987, “all similar in expressive power and semantic underpinnings.” The best known was Miranda, designed by David Turner at the University of Kent as the successor to his languages SASL and KRC and first released in 1985. Miranda added the polymorphic type inference of ML to lazy evaluation and had the best implementation. It was also a commercial product of Turner’s company, Research Software Ltd. Turner footnoted every first mention of Miranda in his papers as a trademark, and its license required permission before anyone distributed an implementation of Miranda or of a language “substantially copied” from it. Some early Haskell talks answered with a footnote of their own: “Haskell is not a trademark.” Chalmers University in Sweden had its own Lazy ML, and Glasgow, Yale and others had languages of their own.

Each group spent part of every paper describing its language before it could describe its implementation techniques, and none had enough users to matter outside research. In September 1987, at the conference on Functional Programming Languages and Computer Architecture (FPCA) in Portland, Oregon, the researchers met and agreed to design one common language.

Naming a Language

The committee met at University College London in December 1987, at Yale in January 1988 and at the University of Glasgow from 6 to 9 April 1988, where many of the key decisions were taken and Paul Hudak and Philip Wadler were chosen to edit the report. Most of the work happened by email.

The name was chosen at Yale. The members wrote candidates on a blackboard (among them Semla, Vivaldi, Mozart, Fun, Curry, Frege, Peano and Haskell B Curry) and then took turns crossing out names they disliked until one was left: “Curry”, after the logician Haskell Brooks Curry, whose combinatory logic underlies functional programming and whose name had already given the field the verb “currying”. That night two of them realized the language would attract endless curry puns, the worst being Tim Curry, the star of The Rocky Horror Picture Show, since TIM was also the name of Jon Fairbairn’s abstract machine. The next day they settled on “Haskell” instead, and only later noticed that it could be confused with Pascal or “hassle”. Hudak and David Wise wrote to Curry’s widow, Virginia Curry, to ask permission. Hudak later visited her and gave a talk at Penn State that she attended; her parting remark was: “You know, Haskell actually never liked the name Haskell.”

The Reports

Paul Hudak 2013
Paul Hudak of Yale, co-editor of the first Haskell Report, in 2013. Image: John Peterson, CC BY 2.0, via Wikimedia Commons.

The Haskell 1.0 Report, 125 pages edited by Hudak and Wadler, was published on 1 April 1990. The date was mostly an accident, the authors wrote later, but it did not stop a series of April Fool’s jokes about the language in the years that followed. A public mailing list opened at the same time. Version 1.2 (March 1992) was printed in full in SIGPLAN Notices in May 1992 with a “Gentle Introduction to Haskell” by Hudak and Joseph Fasel, which gave the language visibility beyond the committee. In 1994 John Peterson registered haskell.org.

The most important revision was Haskell 1.3 (May 1996), which added a standard library and replaced the original input/output system with monads and the do notation. Haskell 98, published in February 1999 and edited by Simon Peyton Jones and John Hughes, was a deliberate commitment to stability: a fixed language that textbooks, courses and compilers could rely on while research continued in extensions. A revised Haskell 98 report followed in December 2002, and Haskell 2010, published in July 2010, made modest additions such as a foreign-function interface and hierarchical module names.

Purity and the Problem of Input

Philip Wadler
Philip Wadler, co-editor of the first Haskell Report, who brought monads into functional programming, lecturing at Edinburgh in 2008. Image: Clq, CC BY 3.0, via Wikimedia Commons.

Haskell is purely functional. A function given the same arguments always returns the same result, and it cannot change a global variable, print to the screen or read a file as a hidden side effect. This property, called referential transparency, lets programmers and compilers replace any expression by its value, reorder computations and reason about programs algebraically.

Laziness made purity a necessity rather than a choice. If the order of evaluation depends on what is needed when, a side effect inside a function could happen at an unpredictable moment, or not at all. But a program that cannot read input or write output is useless. Haskell 1.0 described input and output as streams of requests and responses passed between the program and the operating system, and in addition as continuations; the committee found the two equivalent, and both were awkward to use.

The solution came from semantics. In 1989 Eugenio Moggi showed at the LICS conference how monads, a structure from category theory, could describe features of programming languages such as state and exceptions in a uniform way. Wadler recognized that the same technique could structure ordinary functional programs, and wrote it up in 1992. Peyton Jones and Wadler then applied it to input and output in a 1993 paper they called “Imperative functional programming”. A value of type IO String is not a string but a description of an action that, when executed, will produce one; actions are combined in sequence with a monadic operator, and the do notation makes the result read like an imperative program. Pure code cannot run an IO action, so the type of every function shows whether it can touch the outside world.

The same structure turned out to describe many other things: optional values, lists, parsers, state, exceptions and asynchronous computation. Erik Meijer, a member of the Haskell community who later designed LINQ for Microsoft’s C#, said that LINQ was directly inspired by Haskell’s monad comprehensions, and promise and async libraries in many languages follow the same pattern.

Type Classes

The committee wanted overloading: the same + for integers and floating-point numbers, the same == for any type that supports equality. ML handled this with special cases. During the design process Wadler and Stephen Blott proposed type classes, building on an insight from Joseph Fasel that overloading should be reflected in a function’s type. A type class such as Eq names a set of operations; a type becomes an instance of the class by supplying them; and a function’s type records which classes it relies on (elem :: Eq a => a -> [a] -> Bool). Blott proved the system sound for his doctoral thesis, and Stefan Kaes had formulated a similar idea independently.

Type classes became Haskell’s most distinctive feature and the basis of much later research: constructor classes, which made it possible to define Monad itself as a class, multi-parameter classes and type families. They are the direct ancestor of traits in Rust, and related ideas appear in Scala’s implicits, Swift’s protocols and the concepts of C++20.

With Hindley-Milner type inference, the compiler deduces the types of most expressions without annotations, so Haskell code is strictly typed but rarely cluttered with types. Haskell programmers’ saying “if it compiles, it works” is an exaggeration, but it describes how many errors the type checker catches before a program runs.

The Price of Laziness

Laziness also brought Haskell’s most persistent practical problem. Because an expression is evaluated only when needed, a program can build up large chains of unevaluated computations (“thunks”) that consume memory until something finally forces them. The official history states it plainly: “it is very hard for even experienced programmers to predict the space behaviour of lazy programs, and there can be much more than a constant factor at stake.” These space leaks led the committee to add strict features, such as the seq function and strictness annotations on data types, which compromised the language’s semantic purity in exchange for control. Later dialects went further: Standard Chartered’s in-house language Mu, written by Lennart Augustsson, is a strict variant of Haskell.

Compilers and Tools

The Glasgow Haskell Compiler (GHC) was started at the University of Glasgow in January 1989, as soon as the initial design was settled. Kevin Hammond wrote the first version in Lazy ML as a new front end for the Chalmers compiler; it began working in June 1989, just as Simon Peyton Jones arrived in Glasgow. Peyton Jones and Simon Marlow moved to Microsoft Research in Cambridge in 1997 and continued to lead GHC there. Lennart Augustsson at Chalmers wrote the first complete Haskell compiler, hbc, in 1990, while waiting for Glasgow’s. The interpreter Hugs gave Haskell a fast interactive environment on Unix and Windows. Together they explain why Haskell overtook Miranda by the mid-1990s: one small company could not keep up with several university groups, and Miranda ran only under Unix.

GHC grew into a research platform. Ideas such as generalized algebraic data types, type families, rank-n types and software transactional memory (2005) appeared first as GHC extensions, each switched on with a pragma, and some later reached other languages. Library distribution came late: Isaac Jones started the package system Cabal in 2004, David Himmelstrup built the package server Hackage, and the Stack build tool followed in 2015.

Haskell at Work

Haskell’s commercial users are specialized but real. The authors of the official history noted the moment when people began learning Haskell because of programs written in it: Darcs, a version-control system written by the physicist David Roundy, and Pugs, the first implementation of Perl 6, which Audrey Tang wrote in Haskell in 2005 after teaching herself the language in a month. John Hughes and Koen Claessen’s QuickCheck introduced property-based testing, in which the programmer states a property and the tool generates random tests to find a counterexample; versions now exist for most languages. Hardware designers used Haskell-based languages such as Bluespec, and the defence contractor Galois built a business on it.

John MacFarlane released pandoc, a converter between document formats, on 3 August 2006; it became the most widely used program written in Haskell. Banks such as Standard Chartered used Haskell and its dialects for pricing and risk. At Facebook, the Sigma system, which checks posts and messages for spam and abuse, was rewritten in Haskell using Simon Marlow’s Haxl library, which batches and parallelizes data fetches automatically. In 2015 Facebook reported that it served more than one million requests per second and handled 20 to 30 percent more traffic on the same hardware than its predecessor.

Peyton Jones summed up the community’s attitude in the unofficial motto “avoid success at all costs”. He explained that it could be read two ways: avoid “success at all costs” (do not compromise principles to win users), or “avoid success”, at all costs, because a language with many users can no longer change. In 2021 he left Microsoft for Epic Games to work on Verse, a new functional language.

Ideas That Travelled

Haskell’s influence is clearer in other languages than in its own usage figures:

  • Algebraic data types and pattern matching spread to Rust, Swift, Scala, Kotlin, Java (records and sealed types) and Python 3.10.
  • Type classes led to Rust traits and influenced Swift protocols and C++ concepts.
  • Monads shaped LINQ, Optional and Promise types, and the async/await designs of several languages.
  • Property-based testing from QuickCheck spread to Hypothesis for Python, ScalaCheck and many others.
  • Software transactional memory was first made practical in Haskell.
  • Immutability by default and type inference are now standard in new languages.

Much of this came through ML and its descendants as well, and many of the ideas are older than Haskell, but Haskell was where they were combined in a language people used and wrote papers about.

Dead End

The committee that began in 1987 set out to give the research community one standard language. The standard stopped growing after 2010.

In the 2000s a successor called Haskell′ (“Haskell Prime”) was discussed for years and produced Haskell 2010, a small revision. A Haskell 2020 committee was formed in 2016 to write the next report and stalled; by 2019 its mailing list had been silent for most of two years and the effort was widely described as dead. Beyond a lack of leadership, the deeper reason was that GHC had become the language. Real programs switched on dozens of GHC extensions, libraries depended on them, and the community could not agree which to standardize. GHC adopted a different approach: GHC2021 and GHC2024 are named bundles of uncontroversial extensions, chosen by the GHC steering committee rather than written into a report. In practice Haskell is defined by one compiler, and the 2010 report no longer describes the language programmers write: changes such as making Applicative a superclass of Monad were never added to it. In August 2026 the Haskell Foundation started a working group to produce a revised Haskell 2010 report that matches current compilers, aiming to finish by the end of the year.

Miranda, the language Haskell replaced, is the other dead end. Research Software could not keep pace with several university groups writing free compilers, and Miranda faded in the 1990s. Turner released it as open source under a BSD license in 2020; he died on 19 October 2023.

📚 Sources