Copyright  (c) The University of Glasgow 2009 

License  see libraries/ghcprim/LICENSE 
Maintainer  cvsghc@haskell.org 
Stability  internal 
Portability  nonportable (GHC Extensions) 
Safe Haskell  None 
Language  Haskell2010 
GHC type definitions. Use GHC.Exts from the base package instead of importing this module directly.
Synopsis
 data Bool
 data Char = C# Char#
 data Int = I# Int#
 data Word = W# Word#
 data Float = F# Float#
 data Double = D# Double#
 data Ordering
 newtype IO a = IO (State# RealWorld > (# State# RealWorld, a #))
 isTrue# :: Int# > Bool
 data SPEC
 data Nat
 data Symbol
 type family Any :: k where ...
 class a ~~ b
 class Coercible a b
 data TYPE (a :: RuntimeRep)
 data RuntimeRep
 type Type = TYPE 'LiftedRep
 data Constraint
 data VecCount
 data VecElem
 data Module = Module TrName TrName
 data TrName
 data TyCon = TyCon Word# Word# Module TrName Int# KindRep
 data TypeLitSort
 data KindRep
 type KindBndr = Int
Documentation
The character type Char
is an enumeration whose values represent
Unicode (or equivalently ISO/IEC 10646) code points (i.e. characters, see
http://www.unicode.org/ for details). This set extends the ISO 88591
(Latin1) character set (the first 256 characters), which is itself an extension
of the ASCII character set (the first 128 characters). A character literal in
Haskell has type Char
.
To convert a Char
to or from the corresponding Int
value defined
by Unicode, use toEnum
and fromEnum
from the
Enum
class respectively (or equivalently ord
and
chr
).
A fixedprecision integer type with at least the range [2^29 .. 2^291]
.
The exact range for a given implementation can be determined by using
minBound
and maxBound
from the Bounded
class.
Singleprecision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE singleprecision type.
Instances
Eq Float #  Note that due to the presence of
Also note that

Ord Float #  Note that due to the presence of
Also note that, due to the same,

Defined in GHC.Classes 
Doubleprecision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE doubleprecision type.
Instances
Eq Double #  Note that due to the presence of
Also note that

Ord Double #  Note that due to the presence of
Also note that, due to the same,

Defined in GHC.Classes 
Instances
Eq Ordering #  
Ord Ordering #  
Defined in GHC.Classes 
A value of type
is a computation which, when performed,
does some I/O before returning a value of type IO
aa
.
There is really only one way to "perform" an I/O action: bind it to
Main.main
in your program. When your program is run, the I/O will
be performed. It isn't possible to perform I/O from an arbitrary
function, unless that function is itself in the IO
monad and called
at some point, directly or indirectly, from Main.main
.
IO
is a monad, so IO
actions can be combined using either the donotation
or the >>
and >>=
operations from the Monad
class.
isTrue# :: Int# > Bool Source #
Alias for tagToEnum#
. Returns True if its parameter is 1# and False
if it is 0#.
SPEC
is used by GHC in the SpecConstr
pass in order to inform
the compiler when to be particularly aggressive. In particular, it
tells GHC to specialize regardless of size or the number of
specializations. However, not all loops fall into this category.
Libraries can specify this by using SPEC
data type to inform which
loops should be aggressively specialized.
(Kind) This is the kind of typelevel symbols. Declared here because class IP needs it
type family Any :: k where ... Source #
The type constructor Any
is type to which you can unsafely coerce any
lifted type, and back. More concretely, for a lifted type t
and
value x :: t
,  unsafeCoerce (unsafeCoerce x :: Any) :: t
is equivalent
to x
.
Lifted, heterogeneous equality. By lifted, we mean that it
can be bogus (deferred type error). By heterogeneous, the two
types a
and b
might have different kinds. Because ~~
can
appear unexpectedly in error messages to users who do not care
about the difference between heterogeneous equality ~~
and
homogeneous equality ~
, this is printed as ~
unless
fprintequalityrelations
is set.
Coercible
is a twoparameter class that has instances for types a
and b
if
the compiler can infer that they have the same representation. This class
does not have regular instances; instead they are created onthefly during
typechecking. Trying to manually declare an instance of Coercible
is an error.
Nevertheless one can pretend that the following three kinds of instances exist. First, as a trivial basecase:
instance Coercible a a
Furthermore, for every type constructor there is
an instance that allows to coerce under the type constructor. For
example, let D
be a prototypical type constructor (data
or
newtype
) with three type arguments, which have roles nominal
,
representational
resp. phantom
. Then there is an instance of
the form
instance Coercible b b' => Coercible (D a b c) (D a b' c')
Note that the nominal
type arguments are equal, the
representational
type arguments can differ, but need to have a
Coercible
instance themself, and the phantom
type arguments can be
changed arbitrarily.
The third kind of instance exists for every newtype NT = MkNT T
and
comes in two variants, namely
instance Coercible a T => Coercible a NT
instance Coercible T b => Coercible NT b
This instance is only usable if the constructor MkNT
is in scope.
If, as a library author of a type constructor like Set a
, you
want to prevent a user of your module to write
coerce :: Set T > Set NT
,
you need to set the role of Set
's type parameter to nominal
,
by writing
type role Set nominal
For more details about this feature, please refer to Safe Coercions by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich.
Since: ghcprim4.7.0.0
data TYPE (a :: RuntimeRep) Source #
data RuntimeRep Source #
GHC maintains a property that the kind of all inhabited types
(as distinct from type constructors or typelevel data) tells us
the runtime representation of values of that type. This datatype
encodes the choice of runtime value.
Note that TYPE
is parameterised by RuntimeRep
; this is precisely
what we mean by the fact that a type's kind encodes the runtime
representation.
For boxed values (that is, values that are represented by a pointer), a further distinction is made, between lifted types (that contain ⊥), and unlifted ones (that don't).
VecRep VecCount VecElem  a SIMD vector type 
TupleRep [RuntimeRep]  An unboxed tuple of the given reps 
SumRep [RuntimeRep]  An unboxed sum of the given reps 
LiftedRep  lifted; represented by a pointer 
UnliftedRep  unlifted; represented by a pointer 
IntRep  signed, wordsized value 
Int8Rep  signed, 8bit value 
Int16Rep  signed, 16bit value 
Int32Rep  signed, 32bit value 
Int64Rep  signed, 64bit value (on 32bit only) 
WordRep  unsigned, wordsized value 
Word8Rep  unsigned, 8bit value 
Word16Rep  unsigned, 16bit value 
Word32Rep  unsigned, 32bit value 
Word64Rep  unsigned, 64bit value (on 32bit only) 
AddrRep  A pointer, but not to a Haskell value 
FloatRep  a 32bit floating point number 
DoubleRep  a 64bit floating point number 
data Constraint Source #
The kind of constraints, like Show a
Element of a SIMD vector type
Runtime type representation
The representation produced by GHC for conjuring up the kind of a
TypeRep
.