GHC.Exts

Haskell Hierarchical Libraries (base package)

GHC.Exts

Portability	non-portable (GHC Extensions)
Stability	internal
Maintainer	cvs-ghc@haskell.org

Contents

Representations of some basic types
Primitive operations
Fusion
Linear implicit parameter support

Description

GHC Extensions: this is the Approved Way to get at GHC-specific extensions.

Synopsis

data Int = I# Int#

data Word = W# Word#

data Float = F# Float#

data Double = D# Double#

data Integer

= S# Int#

| J# Int# ByteArray#

data Char = C# Char#

data Ptr a = Ptr Addr#

data FunPtr a = FunPtr Addr#

shiftL# :: Word# -> Int# -> Word#

shiftRL# :: Word# -> Int# -> Word#

iShiftL# :: Int# -> Int# -> Int#

iShiftRA# :: Int# -> Int# -> Int#

iShiftRL# :: Int# -> Int# -> Int#

build :: forall a . (forall b . (a -> b -> b) -> b -> b) -> [a]

augment :: forall a . (forall b . (a -> b -> b) -> b -> b) -> [a] -> [a]

class Splittable t where

split :: t -> (t, t)

Representations of some basic types

data Int

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

MArray IOUArray Int IO

IArray (IOToDiffArray IOUArray) Int

MArray (STUArray s) Int (ST s)

Ix ix => Eq (UArray ix Int)

Ix ix => Ord (UArray ix Int)

(Ix ix, Show ix) => Show (DiffUArray ix Int)

(Ix ix, Show ix) => Show (UArray ix Int)

data Word

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

Constructors

W# Word#

Instances

MArray IOUArray Word IO

IArray (IOToDiffArray IOUArray) Word

MArray (STUArray s) Word (ST s)

Ix ix => Eq (UArray ix Word)

Ix ix => Ord (UArray ix Word)

(Ix ix, Show ix) => Show (DiffUArray ix Word)

(Ix ix, Show ix) => Show (UArray ix Word)

data Float

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

MArray IOUArray Float IO

IArray (IOToDiffArray IOUArray) Float

MArray (STUArray s) Float (ST s)

Ix ix => Eq (UArray ix Float)

Ix ix => Ord (UArray ix Float)

(Ix ix, Show ix) => Show (DiffUArray ix Float)

(Ix ix, Show ix) => Show (UArray ix Float)

data Double

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

MArray IOUArray Double IO

IArray (IOToDiffArray IOUArray) Double

MArray (STUArray s) Double (ST s)

Ix ix => Eq (UArray ix Double)

Ix ix => Ord (UArray ix Double)

(Ix ix, Show ix) => Show (DiffUArray ix Double)

(Ix ix, Show ix) => Show (UArray ix Double)

data Integer

Arbitrary-precision integers.

Constructors

S# Int#
J# Int# ByteArray#

Instances

data Char

The character type Char is an enumeration whose values represent Unicode (or equivalently ISO 10646) characters. This set extends the ISO 8859-1 (Latin-1) character set (the first 256 charachers), 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

MArray IOUArray Char IO

IArray (IOToDiffArray IOUArray) Char

MArray (STUArray s) Char (ST s)

Ix ix => Eq (UArray ix Char)

Ix ix => Ord (UArray ix Char)

(Ix ix, Show ix) => Show (DiffUArray ix Char)

(Ix ix, Show ix) => Show (UArray ix Char)

data Ptr a

A value of type Ptr a represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of type a.

The type a will often be an instance of class Storable which provides the marshalling operations. However this is not essential, and you can provide your own operations to access the pointer. For example you might write small foreign functions to get or set the fields of a C struct.

Constructors

Ptr Addr#

Instances

Typeable1 Ptr

IArray UArray (Ptr a)

MArray IOUArray (Ptr a) IO

Typeable a => Data (Ptr a)

Eq (Ptr a)

Ord (Ptr a)

Show (Ptr a)

Storable (Ptr a)

IArray (IOToDiffArray IOUArray) (Ptr a)

MArray (STUArray s) (Ptr a) (ST s)

Ix ix => Eq (UArray ix (Ptr a))

Ix ix => Ord (UArray ix (Ptr a))

data FunPtr a

A value of type FunPtr a is a pointer to a function callable from foreign code. The type a will normally be a foreign type, a function type with zero or more arguments where

the argument types are marshallable foreign types, i.e. Char, Int, Double, Float, Bool, Int8, Int16, Int32, Int64, Word8, Word16, Word32, Word64, Ptr a, FunPtr a, StablePtr a or a renaming of any of these using newtype.
the return type is either a marshallable foreign type or has the form IO t where t is a marshallable foreign type or ().

A value of type FunPtr a may be a pointer to a foreign function, either returned by another foreign function or imported with a a static address import like

 foreign import ccall "stdlib.h &free"
   p_free :: FunPtr (Ptr a -> IO ())

or a pointer to a Haskell function created using a wrapper stub declared to produce a FunPtr of the correct type. For example:

 type Compare = Int -> Int -> Bool
 foreign import ccall "wrapper"
   mkCompare :: Compare -> IO (FunPtr Compare)

Calls to wrapper stubs like mkCompare allocate storage, which should be released with freeHaskellFunPtr when no longer required.

To convert FunPtr values to corresponding Haskell functions, one can define a dynamic stub for the specific foreign type, e.g.

 type IntFunction = CInt -> IO ()
 foreign import ccall "dynamic" 
   mkFun :: FunPtr IntFunction -> IntFunction

Constructors

FunPtr Addr#

Instances

Typeable1 FunPtr

IArray UArray (FunPtr a)

MArray IOUArray (FunPtr a) IO

Eq (FunPtr a)

Ord (FunPtr a)

Show (FunPtr a)

Storable (FunPtr a)

IArray (IOToDiffArray IOUArray) (FunPtr a)

MArray (STUArray s) (FunPtr a) (ST s)

Ix ix => Eq (UArray ix (FunPtr a))

Ix ix => Ord (UArray ix (FunPtr a))

Primitive operations

shiftL# :: Word# -> Int# -> Word#

Shift the argument left by the specified number of bits (which must be non-negative).

shiftRL# :: Word# -> Int# -> Word#

Shift the argument right by the specified number of bits (which must be non-negative).

iShiftL# :: Int# -> Int# -> Int#

Shift the argument left by the specified number of bits (which must be non-negative).

iShiftRA# :: Int# -> Int# -> Int#

Shift the argument right (signed) by the specified number of bits (which must be non-negative).

iShiftRL# :: Int# -> Int# -> Int#

Shift the argument right (unsigned) by the specified number of bits (which must be non-negative).

Fusion

build :: forall a . (forall b . (a -> b -> b) -> b -> b) -> [a]

A list producer that can be fused with foldr. This function is merely

	build g = g (:) []

but GHC's simplifier will transform an expression of the form foldr k z (build g), which may arise after inlining, to g k z, which avoids producing an intermediate list.

augment :: forall a . (forall b . (a -> b -> b) -> b -> b) -> [a] -> [a]

A list producer that can be fused with foldr. This function is merely

	augment g xs = g (:) xs

but GHC's simplifier will transform an expression of the form foldr k z (augment g xs), which may arise after inlining, to g k (foldr k z xs), which avoids producing an intermediate list.

Linear implicit parameter support

class Splittable t where

Methods

split :: t -> (t, t)

Produced by Haddock version 0.7