This section lists Glasgow Haskell infelicities in its
implementation of Haskell 98. See also the “when things
go wrong” section (Chapter 9) for information
about crashes, space leaks, and other undesirable phenomena.
The limitations here are listed in Haskell Report order
The Haskell report specifies that programs may be
written using Unicode. GHC only accepts the ISO-8859-1
character set at the moment.
Certain lexical rules regarding qualified identifiers
are slightly different in GHC compared to the Haskell
report. When you have
such as M.\, GHC will interpret it as a
single qualified operator rather than the two lexemes
M and .\.
When -fglasgow-exts is on, GHC
reserves several keywords beginning with two underscores.
This is due to the fact that GHC uses the same lexical
analyser for interface file parsing as it does for source
file parsing, and these keywords are used in interface
files. Do not use any identifiers beginning with a double
underscore in -fglasgow-exts mode.
GHC doesn't do fixity resolution in expressions during
parsing. For example, according to the Haskell report, the
following expression is legal Haskell:
let x = 42 in x == 42 == True
and parses as:
(let x = 42 in x == 42) == True
because according to the report, the let
expression "extends as far to the right as
possible". Since it can't extend past the second
equals sign without causing a parse error
(== is non-fix), the
let-expression must terminate there. GHC
simply gobbles up the whole expression, parsing like this:
(let x = 42 in x == 42 == True)
The Haskell report is arguably wrong here, but nevertheless
it's a difference between GHC & Haskell 98.
Several modules internal to GHC are visible in the
standard namespace. All of these modules begin with
Prel, so the rule is: don't use any
modules beginning with Prel in your
program, or you may be comprehensively screwed.
This section documents GHC's take on various issues that are
left undefined or implementation specific in Haskell 98.
Sized integral types
In GHC the Int type follows the
size of an address on the host architecture; in other words
it holds 32 bits on a 32-bit machine, and 64-bits on a
Arithmetic on Int is unchecked for
overflow, so all operations on Int happen
where n is the size in bits of
the Int type.
The fromIntegerfunction (and hence
also fromIntegral) is a special case when
converting to Int. The value of
fromIntegral x :: Int is given by taking
the lower n bits of (abs
x), multiplied by the sign of x
(in 2's complement n-bit
arithmetic). This behaviour was chosen so that for example
writing 0xffffffff :: Int preserves the
bit-pattern in the resulting Int.
Negative literals, such as -3, are
specified by (a careful reading of) the Haskell Report as
meaning Prelude.negate (Prelude.fromInteger 3).
So -2147483648 means negate (fromInteger 2147483648).
Since fromInteger takes the lower 32 bits of the representation,
fromInteger (2147483648::Integer), computed at type Int is
-2147483648::Int. The negate operation then
overflows, but it is unchecked, so negate (-2147483648::Int) is just
-2147483648. In short, one can write minBound::Int as
a literal with the expected meaning (but that is not in general guaranteed.
The fromIntegral function also
preserves bit-patterns when converting between the sized
integral types (Int8,
Int64 and the unsigned
Word variants), see the modules
Data.Int and Data.Word
in the library documentation.
Unchecked float arithmetic
Operations on Float and
Double numbers are
unchecked for overflow, underflow, and
other sad occurrences. (note, however that some
architectures trap floating-point overflow and
loss-of-precision and report a floating-point exception,
probably terminating the