ghc-prim-0.3.0.0: GHC primitives

Portabilitynon-portable (GHC Extensions)
Stabilityinternal
Maintainer[email protected]
Safe HaskellNone

GHC.Types

Description

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

Synopsis

Documentation

data Bool Source

Constructors

False 
True 

Instances

Eq Bool 
Ord Bool 

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# 

Instances

Eq Char 
Ord 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# 

Instances

Eq Int 
Ord Int 

data Word Source

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

Constructors

W# Word# 

Instances

Eq Word 
Ord 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# 

Instances

Eq Float 
Ord 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# 

Instances

Eq Double 
Ord Double 

data Ordering Source

Constructors

LT 
EQ 
GT 

Instances

Eq Ordering 
Ord Ordering 

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#))