Copyright | (c) The University of Glasgow 2009 |
---|---|

License | see libraries/ghc-prim/LICENSE |

Maintainer | cvs-ghc@haskell.org |

Stability | internal |

Portability | non-portable (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) :: RuntimeRep -> Type
- 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 8859-1
(Latin-1) 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`

).

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

A value of type

is a computation which, when performed,
does some I/O before returning a value of type `IO`

a`a`

.

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 do-notation
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 type-level 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
`-fprint-equality-relations`

is set.

`Coercible`

is a two-parameter 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 on-the-fly during
type-checking. 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 base-case:

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: ghc-prim-4.7.0.0*

data TYPE (a :: RuntimeRep) :: RuntimeRep -> Type Source #

data RuntimeRep Source #

GHC maintains a property that the kind of all inhabited types
(as distinct from type constructors or type-level 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, word-sized value |

WordRep | unsigned, word-sized value |

Int64Rep | signed, 64-bit value (on 32-bit only) |

Word64Rep | unsigned, 64-bit value (on 32-bit only) |

AddrRep | A pointer, but |

FloatRep | a 32-bit floating point number |

DoubleRep | a 64-bit 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`

. See Note [Representing TyCon kinds: KindRep] in TcTypeable.