Glasgow Haskell Compiler

The Glasgow Haskell Compiler

Original author(s)	Kevin Hammond
Developer(s)	Simon Marlow,Simon Peyton Jones,The Glasgow Haskell Team
Initial release	December 1992(1992-12)
Stable release	9.10.1 / 10 May 2024(10 May 2024)
Repository	gitlab.haskell.org/ghc/ghc.git
Written in	Haskell,C
Operating system	Linux,macOS Catalinaand later,Windows 2000and later,FreeBSD
Platform	x86-64,AArch64
Available in	English
Type	Compiler
License	BSD New
Website	www.haskell.org/ghc

TheGlasgow Haskell Compiler(GHC) is a native ormachine codecompilerfor thefunctional programminglanguageHaskell.It provides across-platform softwareenvironment for writing and testing Haskell code and supports many extensions,libraries,and optimisations that streamline the process of generating and executing code. GHC is the most commonly used Haskell compiler.It isfree and open-source softwarereleased under aBSD license.

History

GHC originally begun in 1989 as a prototype, written inLazy ML(LML) by Kevin Hammond at theUniversity of Glasgow.Later that year, the prototype was completely rewritten in Haskell, except for itsparser,by Cordelia Hall, Will Partain, and Simon Peyton Jones. Its first beta release was on 1 April 1991. Later releases added astrictness analyzerand language extensions such asmonadic I/O,mutable arrays, unboxed data types, concurrent and parallel programming models (such assoftware transactional memoryanddata parallelism) and aprofiler.

Peyton Jones, and Marlow, later moved toMicrosoft ResearchinCambridge,where they continued to be primarily responsible for developing GHC. GHC also contains code from more than three hundred other contributors. From 2009 to about 2014, third-party contributions to GHC were funded by the Industrial Haskell Group.

GHC names

Since early releases the official websitehas referred to GHC asThe Glasgow Haskell Compiler,whereas in the executable version command it is identified asThe Glorious Glasgow Haskell Compilation System.This has been reflected in the documentation.Initially, it had the internal name ofThe Glamorous Glasgow Haskell Compiler.

Architecture

GHC iswritten in Haskell,but theruntime systemfor Haskell, essential to run programs, is written inCandC--.

GHC'sfront end,incorporating thelexer,parser andtypechecker,is designed to preserve as much information about the source language as possible until aftertype inferenceis complete, toward the goal of providing clear error messages to users.After type checking, the Haskell code isdesugaredinto a typedintermediate languageknown as "Core" (based onSystem F,extended withletandcaseexpressions). Core has been extended to supportgeneralized algebraic datatypesin itstype system,and is now based on an extension to System F known as System F_C.

In the tradition of type-directed compiling, GHC's simplifier, or "middle end", where most of theoptimizationsimplemented in GHC are performed, is structured as a series ofsource-to-sourcetransformationson Core code. The analyses and transformations performed in this compiler stage include demand analysis (a generalization ofstrictness analysis), application of user-definedrewrite rules(including a set of rules included in GHC's standard libraries that performs foldr/buildfusion), unfolding (called "inlining"in more traditional compilers),let-floating,an analysis that determines which function arguments can be unboxed,constructed product result analysis,specializationofoverloadedfunctions, and a set of simpler local transformations such asconstant foldingandbeta reduction.

The back end of the compiler transforms Core code into an internal representation of C--, via an intermediate language STG (short for "Spineless Tagless G-machine" ).The C-- code can then take one of three routes: it is either printed as C code for compilation withGCC,converted directly into native machine code (the traditional "code generation"phase), or converted toLLVM IRfor compilation with LLVM. In all three cases, the resultant native code is finally linked against the GHC runtime system to produce an executable.

Language

GHC complies with the language standards, bothHaskell 98andHaskell 2010. It also supports many optional extensions to the Haskell standard: for example, thesoftware transactional memory(STM) library, which allows forComposable Memory Transactions.

Extensions to Haskell

Many extensions to Haskell have been proposed. These provide features not described in the language specification, or they redefine existing constructs. As such, each extension may not be supported by all Haskell implementations. There is an ongoing effortto describe extensions and select those which will be included in future versions of the language specification.

The extensionssupported by the Glasgow Haskell Compiler include:

• Unboxed types and operations. These represent the primitive datatypes of the underlying hardware, without the indirection of a pointer to theheapor the possibility of deferred evaluation. Numerically intensive code can be significantly faster when coded using these types.
• The ability to specifystrict evaluationfor a value, pattern binding, or datatype field.
• More convenient syntax for working with modules, patterns,list comprehensions,operators, records, and tuples.
• Syntactic sugarfor computing witharrowsand recursively-definedmonadicvalues. Both of these concepts extend the monadicdo-notation provided in standard Haskell.
• A significantly more powerful system of types and typeclasses, described below.
• Template Haskell,a system for compile-timemetaprogramming.Expressions can be written to produce Haskell code in the form of anabstract syntax tree.These expressions are typechecked and evaluated at compile time; the generated code is then included as if it were part of the original code. Together with the ability toreflecton definitions, this provides a powerful tool for further extensions to the language.
• Quasi-quotation, which allows the user to define new concrete syntax for expressions and patterns. Quasi-quotation is useful when a metaprogram written in Haskell manipulates code written in a language other than Haskell.
• Generictypeclasses, which specify functions solely in terms of the algebraic structure of the types they operate on.
• Parallel evaluation of expressions using multiple CPU cores. This doesnotrequire explicitly spawning threads. The distribution of work happens implicitly, based on annotations provided in the program.
• Compilerpragmasfor directing optimizations such asinline expansionand specializing functions for particular types.
• Customizable rewrite rules are rules describing how to replace one expression with an equivalent, but more efficiently evaluated expression. These are used within core data structure libraries to provide improved performance throughout application-level code.
• Record dot syntax. Providessyntactic sugarfor accessing the fields of a (potentially nested) record which is similar to the syntax of many other programming languages.

Type system extensions

An expressive static type system is one of the major defining features of Haskell. Accordingly, much of the work in extending the language has been directed towardsdata typesandtype classes.

The Glasgow Haskell Compiler supports an extended type system based on the theoretical System F_C.Major extensions to the type system include:

• Arbitrary-rankandimpredicativepolymorphism.Essentially, a polymorphic function or datatype constructor may require that one of its arguments is also polymorphic.
• Generalized algebraic data types.Each constructor of a polymorphic datatype can encode information into the resulting type. A function which pattern-matches on this type can use the per-constructor type information to perform more specific operations on data.
• Existential types.These can be used to "bundle" some data together with operations on that data, in such a way that the operations can be used without exposing the specific type of the underlying data. Such a value is very similar to anobjectas found inobject-oriented programminglanguages.
• Data types that do not actually contain any values. These can be useful to represent data in type-levelmetaprogramming.
• Type families:user-defined functions from types to types. Whereas parametric polymorphism provides the same structure for every type instantiation, type families providead hocpolymorphism with implementations that can differ between instantiations. Use cases include content-aware optimizing containers and type-level metaprogramming.
• Implicit function parameters that have dynamicscope.These are represented in types in much the same way as type class constraints.
• Linear types(GHC 9.0)

Extensions relating totype classesinclude:

• A type class may be parametrized on more than one type. Thus a type class can describe not only a set of types, but ann-aryrelationon types.
• Functional dependencies,which constrain parts of that relation to be a mathematicalfunctionon types. That is, the constraint specifies that some type class parameter is completely determined once some other set of parameters is fixed. This guides the process oftype inferencein situations where otherwise there would be ambiguity.
• Significantly relaxed rules regarding the allowable shape of type class instances. When these are enabled in full, the type class system becomes aTuring-completelanguage forlogic programmingat compile time.
• Type families, as described above, may also be associated with a type class.
• The automatic generation of certain type class instances is extended in several ways. New type classes forgeneric programmingand common recursion patterns are supported. Also, when a new type is declared asisomorphicto an existing type, any type class instance declared for the underlying type may be lifted to the new type "for free".

Portability

Versions of GHC are available for several system orcomputing platform,includingWindowsand most varieties ofUnix(such asLinux,FreeBSD,OpenBSD,andmacOS).GHC has also beenportedto several differentprocessor architectures.

See also

• Hugs (interpreter)
• Yhc
• Haskell Platform

External links

• Official website