Glasgow Haskell Compiler
From Wikipedia, the free encyclopedia
| Glasgow Haskell Compiler | |
| Developer: | University of Glasgow |
|---|---|
| Latest release: | 6.6 / Oct 11, 2006 |
| OS: | Cross-platform |
| Use: | Compiler |
| License: | BSD |
| Website: | GHC home |
The Glasgow Haskell Compiler (or GHC) is an open source native code compiler for the functional programming language Haskell.
Contents |
[edit] History
GHC originally started in 1989 as a prototype, written in LML (Lazy ML) by Kevin Hammond at the University of Glasgow. Later that year, the prototype was completely rewritten in Haskell, except for its parser, by Cordelia Hall, Will Partain, and Simon Peyton Jones. Its first beta release was on April 1, 1991 and subsequent releases added a strictness analyzer as well as language extensions such as monadic I/O, mutable arrays, unboxed data types, and a profiler.[1]
Peyton Jones, as well as Simon Marlow, later moved to Microsoft Research in Cambridge, England, where they continue to be primarily responsible for developing GHC. GHC also contains code from more than sixty other contributors. [2]
GHC's user manual refers to it as "The Glorious Glasgow Haskell Compilation System".[3]
[edit] Architecture
GHC is itself written in Haskell (in a technique known as bootstrapping), but the runtime system for Haskell — an essential part of the compiler — is written in C and C--. Much of GHC is written in the literate programming style.
GHC's front end — incorporating the lexer, parser and typechecker — is designed to preserve as much information about the source language as possible until after type inference is complete, toward the goal of providing clear error messages to users.[1]
In its last phase, the front end desugars Haskell into a typed intermediate language known as "Core" (based on System F, extended with let and case expressions). In the tradition of type-directed compilation, GHC's simplifier, or "middle end" — where most of the optimizations implemented in GHC are performed — is structured as a series of source-to-source transformations on Core code.[4]
The final stage of the simplifier transforms Core code into STG (short for "Spineless Tagless G-machine"), a lower-level intermediate language. Like Core, STG is itself a functional language, as well as representing an abstract machine. GHC's back end performs transformations on STG before translating it into C, C--, or native machine code (the traditional "code generation" phase).[5]
[edit] Language
GHC complies with the latest language standard, called Haskell 98.[6] It also supports many optional extensions to the Haskell standard: for example, the STM library, which allows for Composable Memory Transactions.
[edit] Portability
Versions of GHC are available for several platforms, including Windows and most varieties of Unix (such as the numerous GNU/Linux flavors and Mac OS X.) GHC has also been ported to several different processor architectures.
[edit] References
- ^ a b Hudak, P.; Hughes, J.; Peyton Jones, S.; Wadler, P. (June 2007). "A history of Haskell: being lazy with class". Proc. Third ACM SIGPLAN History of Programming Languages Conference (HOPL-III).
- ^ The GHC Team. Retrieved on 2007-01-28.
- ^ The Glorious Glasgow Haskell Compilation System User's Guide, Version 6.6. Retrieved on 2007-01-28.
- ^ Peyton Jones, S. (April 1996). "Compiling Haskell by program transformation: a report from the trenches". Proc. European Symposium on Programming (ESOP).
- ^ Peyton Jones, S. (April 1992). "Implementing lazy functional languages on stock hardware: the Spineless Tagless G-machine, Version 2.5". Journal of Functional Programming 2 (2): 127-202.
- ^ Haskell 98 Language and Libraries: The Revised Report. Retrieved on 2007-01-28.
