Haskell 1990
Statically typed and purely functional - optimizes for correctness, composability, and reasoning about code.
Influenced by: OCaml
Haskell is a pure, lazy, statically typed functional language built around a Hindley-Milner type system with type classes and algebraic data types. Purity means functions have no side effects, so effects like I/O are reified as values and sequenced through monads, which makes programs easier to reason about, refactor, and test. It is the language where many ideas now seen in Rust, Scala, and Elm were first made practical.
What makes it distinctive
- Purely functional: functions are referentially transparent, so the same inputs always give the same outputs and there are no hidden side effects.
- Lazy evaluation by default: expressions are only computed when their results are demanded, enabling infinite data structures like
[1..]and clean separation of generation from consumption. - Effects as values: side effects (I/O, state, exceptions) are reified in types like
IO,State,Maybe, andEitherand sequenced with monads and do-notation rather than performed implicitly. - Hindley-Milner type inference: most types are inferred, so programs are strongly statically typed yet often need few or no annotations.
- Type classes: principled ad-hoc polymorphism (Functor, Applicative, Monad, Eq, Ord, Show, and many more) that inspired Rust traits and Scala/Swift protocols.
- Algebraic data types and exhaustive pattern matching make illegal states unrepresentable and let the compiler warn on missing cases.
- Immutability by default: data is persistent and shared safely, which simplifies reasoning, refactoring, and concurrency.
- GHC plus opt-in language extensions (GADTs, type families, rank-N types) make it a research-grade laboratory for type-system ideas.
- Pure foundation for concurrency: Software Transactional Memory (STM) and pure values make parallel and concurrent code far easier to get right.
History
Haskell was born from a committee. By the late 1980s there were more than a dozen lazy purely functional research languages, and the resulting fragmentation made it hard to share code or compare ideas. At the 1987 conference on Functional Programming Languages and Computer Architecture (FPCA) in Portland, researchers agreed to design a single open standard language, and a committee formed to do it. The result was named after the logician Haskell Brooks Curry, whose work on combinatory logic underpins the lambda calculus the language is based on.
The first report, Haskell 1.0, appeared on 1 April 1990. The early versions (1.0 through 1.4) refined the core: lazy evaluation by default, a Hindley-Milner type system extended with type classes (a then-novel idea from Philip Wadler and Stephen Blott for principled ad-hoc polymorphism), and algebraic data types with pattern matching. One of the committee's hardest problems was how a pure language could perform input and output. The answer, worked out largely by Simon Peyton Jones, Philip Wadler, and others drawing on Eugenio Moggi's use of monads in semantics, was to model effects as values of type IO and sequence them with monadic combinators. Wadler's papers popularizing monads for programming were hugely influential well beyond Haskell.
Haskell 98 was published in 1999 (and revised in 2003) as a stable, conservative standard that compiler writers and book authors could target for years. It deliberately froze a clean core so the language could be taught and depended upon, while research extensions continued in compilers. That standard anchored a generation of textbooks and courses.
The Glasgow Haskell Compiler (GHC), begun around 1989 at the University of Glasgow, became the de facto implementation and the laboratory for the language's evolution. Through dozens of opt-in language extensions (enabled with the LANGUAGE pragma) GHC introduced features such as generalized algebraic data types (GADTs), type families, multi-parameter type classes, rank-N types, and much later dependent-type-flavored features. In practice, real-world Haskell is GHC Haskell with a curated set of extensions.
Haskell 2010, released in 2010, was the next and most recent formal standard. It folded in widely used extensions like the foreign function interface (FFI), hierarchical module names, and pattern guards, modernizing the 98 baseline. Since then the community has largely standardized through GHC releases and proposals rather than full language reports.
The ecosystem matured around two pillars: Hackage, the central package repository launched in the mid 2000s, and the build tooling. Cabal (Common Architecture for Building Applications and Libraries) provides the package format and dependency solving; Stack arrived in 2015 with curated, reproducible package sets (LTS snapshots from Stackage) to tame dependency drift. Foundational libraries and ideas such as QuickCheck (property-based testing, by Koen Claessen and John Hughes), Parsec parser combinators, lenses, and Software Transactional Memory all originated or were refined in this community.
Though never a mainstream industrial language, Haskell has had outsized influence. Its type classes, do-notation, monadic effects, parametric polymorphism, and emphasis on purity and immutability shaped Rust (traits, Option/Result, expression orientation), Scala, F#, Elm, PureScript, and Idris, and pushed those ideas into the broader programming world. It is used in production at companies in finance and infrastructure (for example for blockchain, compilers, and data tooling) where its strong static guarantees pay off.
The famous informal slogan, "Avoid success at all costs," captured by Simon Peyton Jones, was a wry commitment to keep Haskell a research vehicle free to evolve rather than be frozen by early commercial demands - a stance widely credited with letting it explore ideas that later reshaped how the industry thinks about types, effects, and composition.