Glasgow Haskell Compiler

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
Glasgow Haskell Compiler
Entwickler Simon Peyton Jones, Simon Marlow
Aktuelle Version 7.8.2[1]
(12. April 2014)
Betriebssystem Plattformunabhängig (UNIX, Windows)
Programmier­sprache Haskell
Kategorie Compiler
Lizenz BSD (Freie Software)
http://haskell.org/ghc/

Der Glasgow Haskell Compiler, auch The Glorious Glasgow Haskell Compilation System[2], aber vor allem bekannt als GHC, ist ein quelloffener Compiler für die Programmiersprache Haskell. Er ist selbst in Haskell geschrieben und erzeugt inzwischen nativen Maschinencode für die jeweilige Plattform.

GHC gilt heute als die Haskell-Implementierung mit den meisten Features und der weitesten Verbreitung.

Geschichte[Bearbeiten]

Der Entwurf von Haskell war Folge der Conference on Functional Programming Languages and Computer Architecture 1987 gewesen, auf der deutlich geworden war, dass die Entwicklung der funktionalen Programmierung durch die vielen verschiedenen Sprachen (viele davon Mitglied der ML-Familie) aufgehalten wurde. Aus diesem Grund sollte eine neue umfassende Sprache entworfen werden, und zwar Haskell.

Kurz darauf begann Kevin Hammond an der Universität von Glasgow (daher auch der Name des Compilers) die Entwicklung einer Implementierung in Lazy ML, die praktisch ein Frontend für eine existierende Lazy-ML-Implementierung darstellte. Als diese Implementierung lauffähig war (Juni 1989), stieß Simon Peyton Jones zu der Entwicklergruppe. Der Prototyp besaß zu diesem Zeitpunkt bereits alle in Haskell 1.0 beschriebenen Eigenschaften und war verhältnismäßig stabil. Allerdings wurde die steigende Komplexität der Implementierung zunehmend zum Problem, da der Compiler groß und langsam wurde. Daraufhin wurden einige Features wieder aus dem offiziellen Standard entfernt.

Im Herbst desselben Jahres begann dann die Arbeit an einer völlig neuen Implementierung (allein der Parser, geschrieben in C und mit der Hilfe von Yacc, wurde übernommen), wieder unter Mitarbeit von S. P. Jones, außerdem Cordelia Hall und Will Partain. Entwickelt wurde komplett in Haskell, möglich wurde dies durch Bootstrapping, indem der neue Compiler zunächst mit der alten Implementierung kompiliert wurde bis die neue Implementierung sich selbst kompilieren konnte (self-hosting). 1992 erschien die erste komplette Version, 0.10. [3]

Funktionsweise[Bearbeiten]

Zunächst wird der Haskell-Code in eine einzige Datenstruktur geparst, um Typprüfungen durchzuführen. Haskell ist eine sehr stark typisierte Sprache, weshalb dieser Schritt sehr wichtig ist (falls hier keine Fehler auftreten ist die Wahrscheinlichkeit, dass das Programm fehlerfrei ist, sehr hoch).

Nach dieser ersten Phase wird das Programm in eine Zwischensprache namens Core umgeformt. Die Core-Sprache (ursprünglich basierend auf dem Lambda-Kalkül) besitzt eine sehr überschaubare Definition, was es einfach macht, Routinen zu schreiben, die sie umformen, zum Beispiel um das Programm zu optimieren. Die Core-Sprache ist eine der Stärken des GHC, da sie eine modulare Optimierungsarchitektur darstellt, die gut angepasst werden kann.[4]

Aus der Core-Form wird eine STG-Darstellung (Spineless Tagless G-machine, eine Erfindung von Jones) erzeugt, aus der dann zunächst C---Code gewonnen wird, um schließlich in C- (inzwischen nicht mehr), LLVM- oder Maschinencode überführt zu werden. Die resultierende Datei wird gegen das GHC-Laufzeitsystem gelinkt, das in C und C-- geschrieben ist.[3]

Sprache[Bearbeiten]

Der GHC unterstützt die beiden wichtigen Haskell-Standards Haskell 98 und Haskell 2010 komplett. Darüber hinaus implementiert er noch viele weitere Erweiterungen der Sprache und des Typsystems.

Bedienung[Bearbeiten]

GHC bietet, ähnlich wie zum Beispiel C-Compiler, viele Sprach- und Warnoptionen auf der Kommandozeile an. Er zeichnet sich außerdem durch die Fähigkeit aus, ganze Programme mittels der Option --make bauen zu können. Dabei werden Modulabhängigkeiten automatisch beachtet und aufgelöst, ähnlich wie bei make.

GHCi[Bearbeiten]

GHCi ist eine interaktive Haskell-Umgebung und Teil von GHC. Es liest einen Haskell-Ausdruck, wertet ihn aus und gibt schließlich das Ergebnis aus. Außerdem ermöglicht GHCi das Kompilieren und Laden von Quelltext, um ihn zu testen, das Einbinden von Modulen und das Ausgeben von Informationen über Funktionen, Typklassen, Datentypen und Module.

Nachfolgend eine Beispielsitzung mit Nachladen von Code, Informationen über Funktionen, Instanzen und Typen etc.:

GHCi, version 7.6.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Prelude> :l 1.hs
[1 of 1] Compiling Main             ( 1.hs, interpreted )
Ok, modules loaded: Main.
*Main> :i toDiffString
toDiffString :: [a] -> DiffString a     -- Defined at 1.hs:7:1
*Main> :i DiffString
newtype DiffString x = DiffString ([x] -> [x])
      -- Defined at 1.hs:4:9
instance Show x => Show (DiffString x) -- Defined at 1.hs:15:10
instance Monoid (DiffString x) -- Defined at 1.hs:18:10
*Main> fromDiffString . toDiffString $ "Hello World!"
Loading package transformers-0.3.0.0 ... linking ... done.
Loading package mtl-2.1.2 ... linking ... done.
"Hello World!"
*Main> :k DiffString
DiffString :: * -> *
*Main>

Kritik[Bearbeiten]

Häufig genannte und 2005 in einer Umfrage bestätigte Kritikpunkte am GHC sind unter anderem seine geringe Geschwindigkeit, die oft schwierig zu entziffernden Fehlermeldungen, die Größe und mangelhafte Ausführungsgeschwindigkeit des erzeugten Codes und die Größe und Unübersichtlichkeit des Quellcodes von GHC.[5]

Einzelnachweise[Bearbeiten]

  1. Release-Log
  2. ghc --version
  3. a b Hudak, Paul, John Hughes, Simon Peyton Jones und Philip Wadler: A History of Haskell: Being Lazy With Class (2007). Proceedings of the Third ACM SIGPLAN History of Programming Languages Conference (HOPL-III)
  4. Simon Peyton Jones: Compiling Haskell by program transformation: a report from the trenches (1996)
  5. GHC Survey