GHC.Types

ghc-prim-0.3.1.0: GHC primitives

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 | Safe-Inferred
Language | Haskell2010

GHC.Types

Description

GHC type definitions. Use GHC.Exts from the base package instead of importing this module directly.

Synopsis

- data Bool
  - = False
  - | True
- data Char = C# Char#
- data Int = I# Int#
- data Word = W# Word#
- data Float = F# Float#
- data Double = D# Double#
- data Ordering
  - = LT
  - | EQ
  - | GT
- newtype IO a = IO (State# RealWorld -> (#State# RealWorld, a#))
- isTrue# :: Int# -> Bool
- data SPEC
  - = SPEC
  - | SPEC2

# Documentation

data Bool Source

Constructors

False |
True |

data Char Source

The character type `Char` is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) 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`).

Constructors

C# Char# |

data Int Source

A fixed-precision integer type with at least the range `[-2^29 .. 2^29-1]`. The exact range for a given implementation can be determined by using `minBound` and `maxBound` from the `Bounded` class.

Constructors

I# Int# |

data Word Source

A `Word` is an unsigned integral type, with the same size as `Int`.

Constructors

W# Word# |

data Float Source

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.

Constructors

F# Float# |

data Double Source

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.

Constructors

D# Double# |

data Ordering Source

Constructors

LT |
EQ |
GT |

newtype IO a Source

A value of type ``IO` a` is a computation which, when performed, does some I/O before returning a value of type `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.

Constructors

IO (State# RealWorld -> (#State# RealWorld, a#)) |

isTrue# :: Int# -> Bool Source

Alias for tagToEnum#. Returns True of its parameter is 1# and False if it is 0#.

data SPEC Source

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.

Constructors

SPEC |
SPEC2 |