GHC.Exts

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

Note: no other base module should import this module.

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

Data Int

Since: base-4.0.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int

toConstr :: Int -> Constr

dataTypeOf :: Int -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int)

gmapT :: (forall b. Data b => b -> b) -> Int -> Int

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r

gmapQ :: (forall d. Data d => d -> u) -> Int -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int

Storable Int

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Int -> Int

alignment :: Int -> Int

peekElemOff :: Ptr Int -> Int -> IO Int

pokeElemOff :: Ptr Int -> Int -> Int -> IO ()

peekByteOff :: Ptr b -> Int -> IO Int

pokeByteOff :: Ptr b -> Int -> Int -> IO ()

peek :: Ptr Int -> IO Int

poke :: Ptr Int -> Int -> IO ()

Bits Int

Since: base-2.1

Defined in GHC.Bits

Methods

(.&.) :: Int -> Int -> Int

(.|.) :: Int -> Int -> Int

xor :: Int -> Int -> Int

complement :: Int -> Int

shift :: Int -> Int -> Int

rotate :: Int -> Int -> Int

zeroBits :: Int

bit :: Int -> Int

setBit :: Int -> Int -> Int

clearBit :: Int -> Int -> Int

complementBit :: Int -> Int -> Int

testBit :: Int -> Int -> Bool

bitSizeMaybe :: Int -> Maybe Int

bitSize :: Int -> Int

isSigned :: Int -> Bool

shiftL :: Int -> Int -> Int

unsafeShiftL :: Int -> Int -> Int

shiftR :: Int -> Int -> Int

unsafeShiftR :: Int -> Int -> Int

rotateL :: Int -> Int -> Int

rotateR :: Int -> Int -> Int

popCount :: Int -> Int

FiniteBits Int

Since: base-4.6.0.0

Defined in GHC.Bits

Methods

finiteBitSize :: Int -> Int

countLeadingZeros :: Int -> Int

countTrailingZeros :: Int -> Int

Bounded Int

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Int

maxBound :: Int

Enum Int

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Int -> Int

pred :: Int -> Int

toEnum :: Int -> Int

fromEnum :: Int -> Int

enumFrom :: Int -> [Int]

enumFromThen :: Int -> Int -> [Int]

enumFromTo :: Int -> Int -> [Int]

enumFromThenTo :: Int -> Int -> Int -> [Int]

Ix Int

Since: base-2.1

Defined in GHC.Ix

Methods

range :: (Int, Int) -> [Int]

index :: (Int, Int) -> Int -> Int

unsafeIndex :: (Int, Int) -> Int -> Int

inRange :: (Int, Int) -> Int -> Bool

rangeSize :: (Int, Int) -> Int

unsafeRangeSize :: (Int, Int) -> Int

Num Int

Since: base-2.1

Defined in GHC.Num

Methods

(+) :: Int -> Int -> Int

(-) :: Int -> Int -> Int

(*) :: Int -> Int -> Int

negate :: Int -> Int

abs :: Int -> Int

signum :: Int -> Int

fromInteger :: Integer -> Int

Read Int

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Int

readList :: ReadS [Int]

readPrec :: ReadPrec Int

readListPrec :: ReadPrec [Int]

Integral Int

Since: base-2.0.1

Defined in GHC.Real

Methods

quot :: Int -> Int -> Int

rem :: Int -> Int -> Int

div :: Int -> Int -> Int

mod :: Int -> Int -> Int

quotRem :: Int -> Int -> (Int, Int)

divMod :: Int -> Int -> (Int, Int)

toInteger :: Int -> Integer

Real Int

Since: base-2.0.1

Defined in GHC.Real

Methods

toRational :: Int -> Rational

Show Int

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Int -> ShowS

show :: Int -> String

showList :: [Int] -> ShowS

PrintfArg Int

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Int -> FieldFormatter

parseFormat :: Int -> ModifierParser

Eq Int

Defined in GHC.Classes

Methods

(==) :: Int -> Int -> Bool

(/=) :: Int -> Int -> Bool

Ord Int

Defined in GHC.Classes

Methods

compare :: Int -> Int -> Ordering

(<) :: Int -> Int -> Bool

(<=) :: Int -> Int -> Bool

(>) :: Int -> Int -> Bool

(>=) :: Int -> Int -> Bool

max :: Int -> Int -> Int

min :: Int -> Int -> Int

Generic1 (URec Int :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Int) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Int a -> Rep1 (URec Int) a

to1 :: forall (a :: k0). Rep1 (URec Int) a -> URec Int a

Foldable (UInt :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UInt m -> m

foldMap :: Monoid m => (a -> m) -> UInt a -> m

foldMap' :: Monoid m => (a -> m) -> UInt a -> m

foldr :: (a -> b -> b) -> b -> UInt a -> b

foldr' :: (a -> b -> b) -> b -> UInt a -> b

foldl :: (b -> a -> b) -> b -> UInt a -> b

foldl' :: (b -> a -> b) -> b -> UInt a -> b

foldr1 :: (a -> a -> a) -> UInt a -> a

foldl1 :: (a -> a -> a) -> UInt a -> a

toList :: UInt a -> [a]

null :: UInt a -> Bool

length :: UInt a -> Int

elem :: Eq a => a -> UInt a -> Bool

maximum :: Ord a => UInt a -> a

minimum :: Ord a => UInt a -> a

sum :: Num a => UInt a -> a

product :: Num a => UInt a -> a

Traversable (UInt :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UInt a -> f (UInt b)

sequenceA :: Applicative f => UInt (f a) -> f (UInt a)

mapM :: Monad m => (a -> m b) -> UInt a -> m (UInt b)

sequence :: Monad m => UInt (m a) -> m (UInt a)

Functor (URec Int :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b

(<$) :: a -> URec Int b -> URec Int a

Generic (URec Int p)

Defined in GHC.Generics

Associated Types

type Rep (URec Int p) :: Type -> Type

Methods

from :: URec Int p -> Rep (URec Int p) x

to :: Rep (URec Int p) x -> URec Int p

Show (URec Int p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Int p -> ShowS

show :: URec Int p -> String

showList :: [URec Int p] -> ShowS

Eq (URec Int p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: URec Int p -> URec Int p -> Bool

(/=) :: URec Int p -> URec Int p -> Bool

Ord (URec Int p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: URec Int p -> URec Int p -> Ordering

(<) :: URec Int p -> URec Int p -> Bool

(<=) :: URec Int p -> URec Int p -> Bool

(>) :: URec Int p -> URec Int p -> Bool

(>=) :: URec Int p -> URec Int p -> Bool

max :: URec Int p -> URec Int p -> URec Int p

min :: URec Int p -> URec Int p -> URec Int p

data URec Int (p :: k)

Used for marking occurrences of Int#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Int (p :: k) = UInt {

• uInt# :: Int#

}

type Rep1 (URec Int :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep1 (URec Int :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UInt" 'PrefixI 'True) (S1 ('MetaSel ('Just "uInt#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UInt :: k -> Type)))

type Rep (URec Int p)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep (URec Int p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UInt" 'PrefixI 'True) (S1 ('MetaSel ('Just "uInt#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UInt :: Type -> Type)))

data Word

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

Constructors

W# Word#

Instances

Data Word

Since: base-4.0.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word

toConstr :: Word -> Constr

dataTypeOf :: Word -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word)

gmapT :: (forall b. Data b => b -> b) -> Word -> Word

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r

gmapQ :: (forall d. Data d => d -> u) -> Word -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word

Storable Word

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Word -> Int

alignment :: Word -> Int

peekElemOff :: Ptr Word -> Int -> IO Word

pokeElemOff :: Ptr Word -> Int -> Word -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word

pokeByteOff :: Ptr b -> Int -> Word -> IO ()

peek :: Ptr Word -> IO Word

poke :: Ptr Word -> Word -> IO ()

Bits Word

Since: base-2.1

Defined in GHC.Bits

Methods

(.&.) :: Word -> Word -> Word

(.|.) :: Word -> Word -> Word

xor :: Word -> Word -> Word

complement :: Word -> Word

shift :: Word -> Int -> Word

rotate :: Word -> Int -> Word

zeroBits :: Word

bit :: Int -> Word

setBit :: Word -> Int -> Word

clearBit :: Word -> Int -> Word

complementBit :: Word -> Int -> Word

testBit :: Word -> Int -> Bool

bitSizeMaybe :: Word -> Maybe Int

bitSize :: Word -> Int

isSigned :: Word -> Bool

shiftL :: Word -> Int -> Word

unsafeShiftL :: Word -> Int -> Word

shiftR :: Word -> Int -> Word

unsafeShiftR :: Word -> Int -> Word

rotateL :: Word -> Int -> Word

rotateR :: Word -> Int -> Word

popCount :: Word -> Int

FiniteBits Word

Since: base-4.6.0.0

Defined in GHC.Bits

Methods

finiteBitSize :: Word -> Int

countLeadingZeros :: Word -> Int

countTrailingZeros :: Word -> Int

Bounded Word

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Word

maxBound :: Word

Enum Word

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Word -> Word

pred :: Word -> Word

toEnum :: Int -> Word

fromEnum :: Word -> Int

enumFrom :: Word -> [Word]

enumFromThen :: Word -> Word -> [Word]

enumFromTo :: Word -> Word -> [Word]

enumFromThenTo :: Word -> Word -> Word -> [Word]

Ix Word

Since: base-4.6.0.0

Defined in GHC.Ix

Methods

range :: (Word, Word) -> [Word]

index :: (Word, Word) -> Word -> Int

unsafeIndex :: (Word, Word) -> Word -> Int

inRange :: (Word, Word) -> Word -> Bool

rangeSize :: (Word, Word) -> Int

unsafeRangeSize :: (Word, Word) -> Int

Num Word

Since: base-2.1

Defined in GHC.Num

Methods

(+) :: Word -> Word -> Word

(-) :: Word -> Word -> Word

(*) :: Word -> Word -> Word

negate :: Word -> Word

abs :: Word -> Word

signum :: Word -> Word

fromInteger :: Integer -> Word

Read Word

Since: base-4.5.0.0

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Word

readList :: ReadS [Word]

readPrec :: ReadPrec Word

readListPrec :: ReadPrec [Word]

Integral Word

Since: base-2.1

Defined in GHC.Real

Methods

quot :: Word -> Word -> Word

rem :: Word -> Word -> Word

div :: Word -> Word -> Word

mod :: Word -> Word -> Word

quotRem :: Word -> Word -> (Word, Word)

divMod :: Word -> Word -> (Word, Word)

toInteger :: Word -> Integer

Real Word

Since: base-2.1

Defined in GHC.Real

Methods

toRational :: Word -> Rational

Show Word

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Word -> ShowS

show :: Word -> String

showList :: [Word] -> ShowS

PrintfArg Word

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Word -> FieldFormatter

parseFormat :: Word -> ModifierParser

Eq Word

Defined in GHC.Classes

Methods

(==) :: Word -> Word -> Bool

(/=) :: Word -> Word -> Bool

Ord Word

Defined in GHC.Classes

Methods

compare :: Word -> Word -> Ordering

(<) :: Word -> Word -> Bool

(<=) :: Word -> Word -> Bool

(>) :: Word -> Word -> Bool

(>=) :: Word -> Word -> Bool

max :: Word -> Word -> Word

min :: Word -> Word -> Word

Generic1 (URec Word :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Word) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Word a -> Rep1 (URec Word) a

to1 :: forall (a :: k0). Rep1 (URec Word) a -> URec Word a

Foldable (UWord :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UWord m -> m

foldMap :: Monoid m => (a -> m) -> UWord a -> m

foldMap' :: Monoid m => (a -> m) -> UWord a -> m

foldr :: (a -> b -> b) -> b -> UWord a -> b

foldr' :: (a -> b -> b) -> b -> UWord a -> b

foldl :: (b -> a -> b) -> b -> UWord a -> b

foldl' :: (b -> a -> b) -> b -> UWord a -> b

foldr1 :: (a -> a -> a) -> UWord a -> a

foldl1 :: (a -> a -> a) -> UWord a -> a

toList :: UWord a -> [a]

null :: UWord a -> Bool

length :: UWord a -> Int

elem :: Eq a => a -> UWord a -> Bool

maximum :: Ord a => UWord a -> a

minimum :: Ord a => UWord a -> a

sum :: Num a => UWord a -> a

product :: Num a => UWord a -> a

Traversable (UWord :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b)

sequenceA :: Applicative f => UWord (f a) -> f (UWord a)

mapM :: Monad m => (a -> m b) -> UWord a -> m (UWord b)

sequence :: Monad m => UWord (m a) -> m (UWord a)

Functor (URec Word :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Word a -> URec Word b

(<$) :: a -> URec Word b -> URec Word a

Generic (URec Word p)

Defined in GHC.Generics

Associated Types

type Rep (URec Word p) :: Type -> Type

Methods

from :: URec Word p -> Rep (URec Word p) x

to :: Rep (URec Word p) x -> URec Word p

Show (URec Word p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Word p -> ShowS

show :: URec Word p -> String

showList :: [URec Word p] -> ShowS

Eq (URec Word p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: URec Word p -> URec Word p -> Bool

(/=) :: URec Word p -> URec Word p -> Bool

Ord (URec Word p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: URec Word p -> URec Word p -> Ordering

(<) :: URec Word p -> URec Word p -> Bool

(<=) :: URec Word p -> URec Word p -> Bool

(>) :: URec Word p -> URec Word p -> Bool

(>=) :: URec Word p -> URec Word p -> Bool

max :: URec Word p -> URec Word p -> URec Word p

min :: URec Word p -> URec Word p -> URec Word p

data URec Word (p :: k)

Used for marking occurrences of Word#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Word (p :: k) = UWord {

• uWord# :: Word#

}

type Rep1 (URec Word :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep1 (URec Word :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: k -> Type)))

type Rep (URec Word p)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep (URec Word p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: Type -> Type)))

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

Data Float

Since: base-4.0.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float

toConstr :: Float -> Constr

dataTypeOf :: Float -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float)

gmapT :: (forall b. Data b => b -> b) -> Float -> Float

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r

gmapQ :: (forall d. Data d => d -> u) -> Float -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float

Storable Float

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Float -> Int

alignment :: Float -> Int

peekElemOff :: Ptr Float -> Int -> IO Float

pokeElemOff :: Ptr Float -> Int -> Float -> IO ()

peekByteOff :: Ptr b -> Int -> IO Float

pokeByteOff :: Ptr b -> Int -> Float -> IO ()

peek :: Ptr Float -> IO Float

poke :: Ptr Float -> Float -> IO ()

Enum Float

Since: base-2.1

Defined in GHC.Float

Methods

succ :: Float -> Float

pred :: Float -> Float

toEnum :: Int -> Float

fromEnum :: Float -> Int

enumFrom :: Float -> [Float]

enumFromThen :: Float -> Float -> [Float]

enumFromTo :: Float -> Float -> [Float]

enumFromThenTo :: Float -> Float -> Float -> [Float]

Floating Float

Since: base-2.1

Defined in GHC.Float

Methods

pi :: Float

exp :: Float -> Float

log :: Float -> Float

sqrt :: Float -> Float

(**) :: Float -> Float -> Float

logBase :: Float -> Float -> Float

sin :: Float -> Float

cos :: Float -> Float

tan :: Float -> Float

asin :: Float -> Float

acos :: Float -> Float

atan :: Float -> Float

sinh :: Float -> Float

cosh :: Float -> Float

tanh :: Float -> Float

asinh :: Float -> Float

acosh :: Float -> Float

atanh :: Float -> Float

log1p :: Float -> Float

expm1 :: Float -> Float

log1pexp :: Float -> Float

log1mexp :: Float -> Float

RealFloat Float

Since: base-2.1

Defined in GHC.Float

Methods

floatRadix :: Float -> Integer

floatDigits :: Float -> Int

floatRange :: Float -> (Int, Int)

decodeFloat :: Float -> (Integer, Int)

encodeFloat :: Integer -> Int -> Float

exponent :: Float -> Int

significand :: Float -> Float

scaleFloat :: Int -> Float -> Float

isNaN :: Float -> Bool

isInfinite :: Float -> Bool

isDenormalized :: Float -> Bool

isNegativeZero :: Float -> Bool

isIEEE :: Float -> Bool

atan2 :: Float -> Float -> Float

Num Float

Note that due to the presence of NaN, not all elements of Float have an additive inverse.

>>> 0/0 + (negate 0/0 :: Float)
NaN

Also note that due to the presence of -0, Float's Num instance doesn't have an additive identity

>>> 0 + (-0 :: Float)
0.0

Since: base-2.1

Defined in GHC.Float

Methods

(+) :: Float -> Float -> Float

(-) :: Float -> Float -> Float

(*) :: Float -> Float -> Float

negate :: Float -> Float

abs :: Float -> Float

signum :: Float -> Float

fromInteger :: Integer -> Float

Read Float

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Float

readList :: ReadS [Float]

readPrec :: ReadPrec Float

readListPrec :: ReadPrec [Float]

Fractional Float

Note that due to the presence of NaN, not all elements of Float have an multiplicative inverse.

>>> 0/0 * (recip 0/0 :: Float)
NaN

Since: base-2.1

Defined in GHC.Float

Methods

(/) :: Float -> Float -> Float

recip :: Float -> Float

fromRational :: Rational -> Float

Real Float

Since: base-2.1

Defined in GHC.Float

Methods

toRational :: Float -> Rational

RealFrac Float

Since: base-2.1

Defined in GHC.Float

Methods

properFraction :: Integral b => Float -> (b, Float)

truncate :: Integral b => Float -> b

round :: Integral b => Float -> b

ceiling :: Integral b => Float -> b

floor :: Integral b => Float -> b

Show Float

Since: base-2.1

Defined in GHC.Float

Methods

showsPrec :: Int -> Float -> ShowS

show :: Float -> String

showList :: [Float] -> ShowS

PrintfArg Float

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Float -> FieldFormatter

parseFormat :: Float -> ModifierParser

Eq Float

Note that due to the presence of NaN, Float's Eq instance does not satisfy reflexivity.

>>> 0/0 == (0/0 :: Float)
False

Also note that Float's Eq instance does not satisfy extensionality:

>>> 0 == (-0 :: Float)
True
>>> recip 0 == recip (-0 :: Float)
False

Defined in GHC.Classes

Methods

(==) :: Float -> Float -> Bool

(/=) :: Float -> Float -> Bool

Ord Float

Note that due to the presence of NaN, Float's Ord instance does not satisfy reflexivity.

>>> 0/0 <= (0/0 :: Float)
False

Also note that, due to the same, Ord's operator interactions are not respected by Float's instance:

>>> (0/0 :: Float) > 1
False
>>> compare (0/0 :: Float) 1
GT

Defined in GHC.Classes

Methods

compare :: Float -> Float -> Ordering

(<) :: Float -> Float -> Bool

(<=) :: Float -> Float -> Bool

(>) :: Float -> Float -> Bool

(>=) :: Float -> Float -> Bool

max :: Float -> Float -> Float

min :: Float -> Float -> Float

Generic1 (URec Float :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Float) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Float a -> Rep1 (URec Float) a

to1 :: forall (a :: k0). Rep1 (URec Float) a -> URec Float a

Foldable (UFloat :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UFloat m -> m

foldMap :: Monoid m => (a -> m) -> UFloat a -> m

foldMap' :: Monoid m => (a -> m) -> UFloat a -> m

foldr :: (a -> b -> b) -> b -> UFloat a -> b

foldr' :: (a -> b -> b) -> b -> UFloat a -> b

foldl :: (b -> a -> b) -> b -> UFloat a -> b

foldl' :: (b -> a -> b) -> b -> UFloat a -> b

foldr1 :: (a -> a -> a) -> UFloat a -> a

foldl1 :: (a -> a -> a) -> UFloat a -> a

toList :: UFloat a -> [a]

null :: UFloat a -> Bool

length :: UFloat a -> Int

elem :: Eq a => a -> UFloat a -> Bool

maximum :: Ord a => UFloat a -> a

minimum :: Ord a => UFloat a -> a

sum :: Num a => UFloat a -> a

product :: Num a => UFloat a -> a

Traversable (UFloat :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b)

sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a)

mapM :: Monad m => (a -> m b) -> UFloat a -> m (UFloat b)

sequence :: Monad m => UFloat (m a) -> m (UFloat a)

Functor (URec Float :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b

(<$) :: a -> URec Float b -> URec Float a

Generic (URec Float p)

Defined in GHC.Generics

Associated Types

type Rep (URec Float p) :: Type -> Type

Methods

from :: URec Float p -> Rep (URec Float p) x

to :: Rep (URec Float p) x -> URec Float p

Show (URec Float p)

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Float p -> ShowS

show :: URec Float p -> String

showList :: [URec Float p] -> ShowS

Eq (URec Float p)

Defined in GHC.Generics

Methods

(==) :: URec Float p -> URec Float p -> Bool

(/=) :: URec Float p -> URec Float p -> Bool

Ord (URec Float p)

Defined in GHC.Generics

Methods

compare :: URec Float p -> URec Float p -> Ordering

(<) :: URec Float p -> URec Float p -> Bool

(<=) :: URec Float p -> URec Float p -> Bool

(>) :: URec Float p -> URec Float p -> Bool

(>=) :: URec Float p -> URec Float p -> Bool

max :: URec Float p -> URec Float p -> URec Float p

min :: URec Float p -> URec Float p -> URec Float p

data URec Float (p :: k)

Used for marking occurrences of Float#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Float (p :: k) = UFloat {

• uFloat# :: Float#

}

type Rep1 (URec Float :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep1 (URec Float :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: k -> Type)))

type Rep (URec Float p)

Defined in GHC.Generics

type Rep (URec Float p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: Type -> Type)))

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

Data Double

Since: base-4.0.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double

toConstr :: Double -> Constr

dataTypeOf :: Double -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double)

gmapT :: (forall b. Data b => b -> b) -> Double -> Double

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r

gmapQ :: (forall d. Data d => d -> u) -> Double -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double

Storable Double

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Double -> Int

alignment :: Double -> Int

peekElemOff :: Ptr Double -> Int -> IO Double

pokeElemOff :: Ptr Double -> Int -> Double -> IO ()

peekByteOff :: Ptr b -> Int -> IO Double

pokeByteOff :: Ptr b -> Int -> Double -> IO ()

peek :: Ptr Double -> IO Double

poke :: Ptr Double -> Double -> IO ()

Enum Double

Since: base-2.1

Defined in GHC.Float

Methods

succ :: Double -> Double

pred :: Double -> Double

toEnum :: Int -> Double

fromEnum :: Double -> Int

enumFrom :: Double -> [Double]

enumFromThen :: Double -> Double -> [Double]

enumFromTo :: Double -> Double -> [Double]

enumFromThenTo :: Double -> Double -> Double -> [Double]

Floating Double

Since: base-2.1

Defined in GHC.Float

Methods

pi :: Double

exp :: Double -> Double

log :: Double -> Double

sqrt :: Double -> Double

(**) :: Double -> Double -> Double

logBase :: Double -> Double -> Double

sin :: Double -> Double

cos :: Double -> Double

tan :: Double -> Double

asin :: Double -> Double

acos :: Double -> Double

atan :: Double -> Double

sinh :: Double -> Double

cosh :: Double -> Double

tanh :: Double -> Double

asinh :: Double -> Double

acosh :: Double -> Double

atanh :: Double -> Double

log1p :: Double -> Double

expm1 :: Double -> Double

log1pexp :: Double -> Double

log1mexp :: Double -> Double

RealFloat Double

Since: base-2.1

Defined in GHC.Float

Methods

floatRadix :: Double -> Integer

floatDigits :: Double -> Int

floatRange :: Double -> (Int, Int)

decodeFloat :: Double -> (Integer, Int)

encodeFloat :: Integer -> Int -> Double

exponent :: Double -> Int

significand :: Double -> Double

scaleFloat :: Int -> Double -> Double

isNaN :: Double -> Bool

isInfinite :: Double -> Bool

isDenormalized :: Double -> Bool

isNegativeZero :: Double -> Bool

isIEEE :: Double -> Bool

atan2 :: Double -> Double -> Double

Num Double

Note that due to the presence of NaN, not all elements of Double have an additive inverse.

>>> 0/0 + (negate 0/0 :: Double)
NaN

Also note that due to the presence of -0, Double's Num instance doesn't have an additive identity

>>> 0 + (-0 :: Double)
0.0

Since: base-2.1

Defined in GHC.Float

Methods

(+) :: Double -> Double -> Double

(-) :: Double -> Double -> Double

(*) :: Double -> Double -> Double

negate :: Double -> Double

abs :: Double -> Double

signum :: Double -> Double

fromInteger :: Integer -> Double

Read Double

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Double

readList :: ReadS [Double]

readPrec :: ReadPrec Double

readListPrec :: ReadPrec [Double]

Fractional Double

Note that due to the presence of NaN, not all elements of Double have an multiplicative inverse.

>>> 0/0 * (recip 0/0 :: Double)
NaN

Since: base-2.1

Defined in GHC.Float

Methods

(/) :: Double -> Double -> Double

recip :: Double -> Double

fromRational :: Rational -> Double

Real Double

Since: base-2.1

Defined in GHC.Float

Methods

toRational :: Double -> Rational

RealFrac Double

Since: base-2.1

Defined in GHC.Float

Methods

properFraction :: Integral b => Double -> (b, Double)

truncate :: Integral b => Double -> b

round :: Integral b => Double -> b

ceiling :: Integral b => Double -> b

floor :: Integral b => Double -> b

Show Double

Since: base-2.1

Defined in GHC.Float

Methods

showsPrec :: Int -> Double -> ShowS

show :: Double -> String

showList :: [Double] -> ShowS

PrintfArg Double

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Double -> FieldFormatter

parseFormat :: Double -> ModifierParser

Eq Double

Note that due to the presence of NaN, Double's Eq instance does not satisfy reflexivity.

>>> 0/0 == (0/0 :: Double)
False

Also note that Double's Eq instance does not satisfy substitutivity:

>>> 0 == (-0 :: Double)
True
>>> recip 0 == recip (-0 :: Double)
False

Defined in GHC.Classes

Methods

(==) :: Double -> Double -> Bool

(/=) :: Double -> Double -> Bool

Ord Double

Note that due to the presence of NaN, Double's Ord instance does not satisfy reflexivity.

>>> 0/0 <= (0/0 :: Double)
False

Also note that, due to the same, Ord's operator interactions are not respected by Double's instance:

>>> (0/0 :: Double) > 1
False
>>> compare (0/0 :: Double) 1
GT

Defined in GHC.Classes

Methods

compare :: Double -> Double -> Ordering

(<) :: Double -> Double -> Bool

(<=) :: Double -> Double -> Bool

(>) :: Double -> Double -> Bool

(>=) :: Double -> Double -> Bool

max :: Double -> Double -> Double

min :: Double -> Double -> Double

Generic1 (URec Double :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Double) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Double a -> Rep1 (URec Double) a

to1 :: forall (a :: k0). Rep1 (URec Double) a -> URec Double a

Foldable (UDouble :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UDouble m -> m

foldMap :: Monoid m => (a -> m) -> UDouble a -> m

foldMap' :: Monoid m => (a -> m) -> UDouble a -> m

foldr :: (a -> b -> b) -> b -> UDouble a -> b

foldr' :: (a -> b -> b) -> b -> UDouble a -> b

foldl :: (b -> a -> b) -> b -> UDouble a -> b

foldl' :: (b -> a -> b) -> b -> UDouble a -> b

foldr1 :: (a -> a -> a) -> UDouble a -> a

foldl1 :: (a -> a -> a) -> UDouble a -> a

toList :: UDouble a -> [a]

null :: UDouble a -> Bool

length :: UDouble a -> Int

elem :: Eq a => a -> UDouble a -> Bool

maximum :: Ord a => UDouble a -> a

minimum :: Ord a => UDouble a -> a

sum :: Num a => UDouble a -> a

product :: Num a => UDouble a -> a

Traversable (UDouble :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UDouble a -> f (UDouble b)

sequenceA :: Applicative f => UDouble (f a) -> f (UDouble a)

mapM :: Monad m => (a -> m b) -> UDouble a -> m (UDouble b)

sequence :: Monad m => UDouble (m a) -> m (UDouble a)

Functor (URec Double :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b

(<$) :: a -> URec Double b -> URec Double a

Generic (URec Double p)

Defined in GHC.Generics

Associated Types

type Rep (URec Double p) :: Type -> Type

Methods

from :: URec Double p -> Rep (URec Double p) x

to :: Rep (URec Double p) x -> URec Double p

Show (URec Double p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Double p -> ShowS

show :: URec Double p -> String

showList :: [URec Double p] -> ShowS

Eq (URec Double p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: URec Double p -> URec Double p -> Bool

(/=) :: URec Double p -> URec Double p -> Bool

Ord (URec Double p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: URec Double p -> URec Double p -> Ordering

(<) :: URec Double p -> URec Double p -> Bool

(<=) :: URec Double p -> URec Double p -> Bool

(>) :: URec Double p -> URec Double p -> Bool

(>=) :: URec Double p -> URec Double p -> Bool

max :: URec Double p -> URec Double p -> URec Double p

min :: URec Double p -> URec Double p -> URec Double p

data URec Double (p :: k)

Used for marking occurrences of Double#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Double (p :: k) = UDouble {

• uDouble# :: Double#

}

type Rep1 (URec Double :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep1 (URec Double :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: k -> Type)))

type Rep (URec Double p)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep (URec Double p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: Type -> Type)))

data Char

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

Constructors

C# Char#

Instances

Data Char

Since: base-4.0.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char

toConstr :: Char -> Constr

dataTypeOf :: Char -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char)

gmapT :: (forall b. Data b => b -> b) -> Char -> Char

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r

gmapQ :: (forall d. Data d => d -> u) -> Char -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char

Storable Char

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Char -> Int

alignment :: Char -> Int

peekElemOff :: Ptr Char -> Int -> IO Char

pokeElemOff :: Ptr Char -> Int -> Char -> IO ()

peekByteOff :: Ptr b -> Int -> IO Char

pokeByteOff :: Ptr b -> Int -> Char -> IO ()

peek :: Ptr Char -> IO Char

poke :: Ptr Char -> Char -> IO ()

Bounded Char

Since: base-2.1

Defined in GHC.Enum

Methods

minBound :: Char

maxBound :: Char

Enum Char

Since: base-2.1

Defined in GHC.Enum

Methods

succ :: Char -> Char

pred :: Char -> Char

toEnum :: Int -> Char

fromEnum :: Char -> Int

enumFrom :: Char -> [Char]

enumFromThen :: Char -> Char -> [Char]

enumFromTo :: Char -> Char -> [Char]

enumFromThenTo :: Char -> Char -> Char -> [Char]

Ix Char

Since: base-2.1

Defined in GHC.Ix

Methods

range :: (Char, Char) -> [Char]

index :: (Char, Char) -> Char -> Int

unsafeIndex :: (Char, Char) -> Char -> Int

inRange :: (Char, Char) -> Char -> Bool

rangeSize :: (Char, Char) -> Int

unsafeRangeSize :: (Char, Char) -> Int

Read Char

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS Char

readList :: ReadS [Char]

readPrec :: ReadPrec Char

readListPrec :: ReadPrec [Char]

Show Char

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

IsChar Char

Since: base-2.1

Defined in Text.Printf

Methods

toChar :: Char -> Char

fromChar :: Char -> Char

PrintfArg Char

Since: base-2.1

Defined in Text.Printf

Methods

formatArg :: Char -> FieldFormatter

parseFormat :: Char -> ModifierParser

Eq Char

Defined in GHC.Classes

Methods

(==) :: Char -> Char -> Bool

(/=) :: Char -> Char -> Bool

Ord Char

Defined in GHC.Classes

Methods

compare :: Char -> Char -> Ordering

(<) :: Char -> Char -> Bool

(<=) :: Char -> Char -> Bool

(>) :: Char -> Char -> Bool

(>=) :: Char -> Char -> Bool

max :: Char -> Char -> Char

min :: Char -> Char -> Char

Generic1 (URec Char :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (URec Char) :: k -> Type

Methods

from1 :: forall (a :: k0). URec Char a -> Rep1 (URec Char) a

to1 :: forall (a :: k0). Rep1 (URec Char) a -> URec Char a

Foldable (UChar :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UChar m -> m

foldMap :: Monoid m => (a -> m) -> UChar a -> m

foldMap' :: Monoid m => (a -> m) -> UChar a -> m

foldr :: (a -> b -> b) -> b -> UChar a -> b

foldr' :: (a -> b -> b) -> b -> UChar a -> b

foldl :: (b -> a -> b) -> b -> UChar a -> b

foldl' :: (b -> a -> b) -> b -> UChar a -> b

foldr1 :: (a -> a -> a) -> UChar a -> a

foldl1 :: (a -> a -> a) -> UChar a -> a

toList :: UChar a -> [a]

null :: UChar a -> Bool

length :: UChar a -> Int

elem :: Eq a => a -> UChar a -> Bool

maximum :: Ord a => UChar a -> a

minimum :: Ord a => UChar a -> a

sum :: Num a => UChar a -> a

product :: Num a => UChar a -> a

Traversable (UChar :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UChar a -> f (UChar b)

sequenceA :: Applicative f => UChar (f a) -> f (UChar a)

mapM :: Monad m => (a -> m b) -> UChar a -> m (UChar b)

sequence :: Monad m => UChar (m a) -> m (UChar a)

Functor (URec Char :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b

(<$) :: a -> URec Char b -> URec Char a

Generic (URec Char p)

Defined in GHC.Generics

Associated Types

type Rep (URec Char p) :: Type -> Type

Methods

from :: URec Char p -> Rep (URec Char p) x

to :: Rep (URec Char p) x -> URec Char p

Show (URec Char p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> URec Char p -> ShowS

show :: URec Char p -> String

showList :: [URec Char p] -> ShowS

Eq (URec Char p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: URec Char p -> URec Char p -> Bool

(/=) :: URec Char p -> URec Char p -> Bool

Ord (URec Char p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: URec Char p -> URec Char p -> Ordering

(<) :: URec Char p -> URec Char p -> Bool

(<=) :: URec Char p -> URec Char p -> Bool

(>) :: URec Char p -> URec Char p -> Bool

(>=) :: URec Char p -> URec Char p -> Bool

max :: URec Char p -> URec Char p -> URec Char p

min :: URec Char p -> URec Char p -> URec Char p

data URec Char (p :: k)

Used for marking occurrences of Char#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec Char (p :: k) = UChar {

• uChar# :: Char#

}

type Compare (a :: Char) (b :: Char)

Defined in Data.Type.Ord

type Compare (a :: Char) (b :: Char) = CmpChar a b

type Rep1 (URec Char :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep1 (URec Char :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UChar" 'PrefixI 'True) (S1 ('MetaSel ('Just "uChar#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UChar :: k -> Type)))

type Rep (URec Char p)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep (URec Char p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UChar" 'PrefixI 'True) (S1 ('MetaSel ('Just "uChar#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UChar :: Type -> Type)))

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

Generic1 (URec (Ptr ()) :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (URec (Ptr ())) :: k -> Type

Methods

from1 :: forall (a :: k0). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a

to1 :: forall (a :: k0). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a

Data a => Data (Ptr a)

Since: base-4.8.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ptr a -> c (Ptr a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ptr a)

toConstr :: Ptr a -> Constr

dataTypeOf :: Ptr a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ptr a))

gmapT :: (forall b. Data b => b -> b) -> Ptr a -> Ptr a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r

gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a)

Foldable (UAddr :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => UAddr m -> m

foldMap :: Monoid m => (a -> m) -> UAddr a -> m

foldMap' :: Monoid m => (a -> m) -> UAddr a -> m

foldr :: (a -> b -> b) -> b -> UAddr a -> b

foldr' :: (a -> b -> b) -> b -> UAddr a -> b

foldl :: (b -> a -> b) -> b -> UAddr a -> b

foldl' :: (b -> a -> b) -> b -> UAddr a -> b

foldr1 :: (a -> a -> a) -> UAddr a -> a

foldl1 :: (a -> a -> a) -> UAddr a -> a

toList :: UAddr a -> [a]

null :: UAddr a -> Bool

length :: UAddr a -> Int

elem :: Eq a => a -> UAddr a -> Bool

maximum :: Ord a => UAddr a -> a

minimum :: Ord a => UAddr a -> a

sum :: Num a => UAddr a -> a

product :: Num a => UAddr a -> a

Traversable (UAddr :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UAddr a -> f (UAddr b)

sequenceA :: Applicative f => UAddr (f a) -> f (UAddr a)

mapM :: Monad m => (a -> m b) -> UAddr a -> m (UAddr b)

sequence :: Monad m => UAddr (m a) -> m (UAddr a)

Storable (Ptr a)

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: Ptr a -> Int

alignment :: Ptr a -> Int

peekElemOff :: Ptr (Ptr a) -> Int -> IO (Ptr a)

pokeElemOff :: Ptr (Ptr a) -> Int -> Ptr a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Ptr a)

pokeByteOff :: Ptr b -> Int -> Ptr a -> IO ()

peek :: Ptr (Ptr a) -> IO (Ptr a)

poke :: Ptr (Ptr a) -> Ptr a -> IO ()

Show (Ptr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

showsPrec :: Int -> Ptr a -> ShowS

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

Eq (Ptr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

(==) :: Ptr a -> Ptr a -> Bool

(/=) :: Ptr a -> Ptr a -> Bool

Ord (Ptr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

compare :: Ptr a -> Ptr a -> Ordering

(<) :: Ptr a -> Ptr a -> Bool

(<=) :: Ptr a -> Ptr a -> Bool

(>) :: Ptr a -> Ptr a -> Bool

(>=) :: Ptr a -> Ptr a -> Bool

max :: Ptr a -> Ptr a -> Ptr a

min :: Ptr a -> Ptr a -> Ptr a

Functor (URec (Ptr ()) :: TYPE LiftedRep -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b

(<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a

Generic (URec (Ptr ()) p)

Defined in GHC.Generics

Associated Types

type Rep (URec (Ptr ()) p) :: Type -> Type

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p

Eq (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

Ord (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering

(<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

data URec (Ptr ()) (p :: k)

Used for marking occurrences of Addr#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec (Ptr ()) (p :: k) = UAddr {

• uAddr# :: Addr#

}

type Rep1 (URec (Ptr ()) :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep1 (URec (Ptr ()) :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UAddr" 'PrefixI 'True) (S1 ('MetaSel ('Just "uAddr#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UAddr :: k -> Type)))

type Rep (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep (URec (Ptr ()) p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UAddr" 'PrefixI 'True) (S1 ('MetaSel ('Just "uAddr#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UAddr :: Type -> Type)))

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

Storable (FunPtr a)

Since: base-2.1

Defined in Foreign.Storable

Methods

sizeOf :: FunPtr a -> Int

alignment :: FunPtr a -> Int

peekElemOff :: Ptr (FunPtr a) -> Int -> IO (FunPtr a)

pokeElemOff :: Ptr (FunPtr a) -> Int -> FunPtr a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (FunPtr a)

pokeByteOff :: Ptr b -> Int -> FunPtr a -> IO ()

peek :: Ptr (FunPtr a) -> IO (FunPtr a)

poke :: Ptr (FunPtr a) -> FunPtr a -> IO ()

Show (FunPtr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

showsPrec :: Int -> FunPtr a -> ShowS

show :: FunPtr a -> String

showList :: [FunPtr a] -> ShowS

Eq (FunPtr a)

Defined in GHC.Ptr

Methods

(==) :: FunPtr a -> FunPtr a -> Bool

(/=) :: FunPtr a -> FunPtr a -> Bool

Ord (FunPtr a)

Defined in GHC.Ptr

Methods

compare :: FunPtr a -> FunPtr a -> Ordering

(<) :: FunPtr a -> FunPtr a -> Bool

(<=) :: FunPtr a -> FunPtr a -> Bool

(>) :: FunPtr a -> FunPtr a -> Bool

(>=) :: FunPtr a -> FunPtr a -> Bool

max :: FunPtr a -> FunPtr a -> FunPtr a

min :: FunPtr a -> FunPtr a -> FunPtr a

The maximum tuple size

maxTupleSize :: Int

Primitive operations

data FUN

The builtin function type, written in infix form as a # m -> b. Values of this type are functions taking inputs of type a and producing outputs of type b. The multiplicity of the input is m.

Note that FUN m a b permits levity-polymorphism in both a and b, so that types like Int# -> Int# can still be well-kinded.

Instances

Category (->)

Since: base-3.0

Defined in Control.Category

Methods

id :: forall (a :: k). a -> a

(.) :: forall (b :: k) (c :: k) (a :: k). (b -> c) -> (a -> b) -> a -> c

Arrow (->)

Since: base-2.1

Defined in Control.Arrow

Methods

arr :: (b -> c) -> b -> c

first :: (b -> c) -> (b, d) -> (c, d)

second :: (b -> c) -> (d, b) -> (d, c)

(***) :: (b -> c) -> (b' -> c') -> (b, b') -> (c, c')

(&&&) :: (b -> c) -> (b -> c') -> b -> (c, c')

ArrowApply (->)

Since: base-2.1

Defined in Control.Arrow

Methods

app :: (b -> c, b) -> c

ArrowChoice (->)

Since: base-2.1

Defined in Control.Arrow

Methods

left :: (b -> c) -> Either b d -> Either c d

right :: (b -> c) -> Either d b -> Either d c

(+++) :: (b -> c) -> (b' -> c') -> Either b b' -> Either c c'

(|||) :: (b -> d) -> (c -> d) -> Either b c -> d

ArrowLoop (->)

Since: base-2.1

Defined in Control.Arrow

Methods

loop :: ((b, d) -> (c, d)) -> b -> c

Monoid b => Monoid (a -> b)

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: a -> b

mappend :: (a -> b) -> (a -> b) -> a -> b

mconcat :: [a -> b] -> a -> b

Semigroup b => Semigroup (a -> b)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: (a -> b) -> (a -> b) -> a -> b

sconcat :: NonEmpty (a -> b) -> a -> b

stimes :: Integral b0 => b0 -> (a -> b) -> a -> b

Show (a -> b)

Since: base-2.1

Defined in Text.Show.Functions

Methods

showsPrec :: Int -> (a -> b) -> ShowS

show :: (a -> b) -> String

showList :: [a -> b] -> ShowS

(PrintfArg a, HPrintfType r) => HPrintfType (a -> r)

Since: base-2.1

Defined in Text.Printf

Methods

hspr :: Handle -> String -> [UPrintf] -> a -> r

(PrintfArg a, PrintfType r) => PrintfType (a -> r)

Since: base-2.1

Defined in Text.Printf

Methods

spr :: String -> [UPrintf] -> a -> r

MonadFix ((->) r)

Since: base-2.1

Defined in Control.Monad.Fix

Methods

mfix :: (a -> r -> a) -> r -> a

Applicative ((->) r)

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> r -> a

(<*>) :: (r -> (a -> b)) -> (r -> a) -> r -> b

liftA2 :: (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c

(*>) :: (r -> a) -> (r -> b) -> r -> b

(<*) :: (r -> a) -> (r -> b) -> r -> a

Functor ((->) r)

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a -> b) -> (r -> a) -> r -> b

(<$) :: a -> (r -> b) -> r -> a

Monad ((->) r)

Since: base-2.1

Defined in GHC.Base

Methods

(>>=) :: (r -> a) -> (a -> r -> b) -> r -> b

(>>) :: (r -> a) -> (r -> b) -> r -> b

return :: a -> r -> a

seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b infixr 0

The value of seq a b is bottom if a is bottom, and otherwise equal to b. In other words, it evaluates the first argument a to weak head normal form (WHNF). seq is usually introduced to improve performance by avoiding unneeded laziness.

A note on evaluation order: the expression seq a b does not guarantee that a will be evaluated before b. The only guarantee given by seq is that the both a and b will be evaluated before seq returns a value. In particular, this means that b may be evaluated before a. If you need to guarantee a specific order of evaluation, you must use the function pseq from the "parallel" package.

realWorld# :: State# RealWorld

The token used in the implementation of the IO monad as a state monad. It does not pass any information at runtime. See also GHC.Magic.runRW#.

void# :: (# #)

This is an alias for the unboxed unit tuple constructor. In earlier versions of GHC, void# was a value of the primitive type Void#, which is now defined to be (# #).

nullAddr# :: Addr#

The null address.

leftSection :: forall {q :: RuntimeRep} {r :: RuntimeRep} {n :: Multiplicity} (a :: TYPE q) (b :: TYPE r). (a %n -> b) -> a %n -> b

rightSection :: forall {q :: RuntimeRep} {r :: RuntimeRep} {s :: RuntimeRep} {n :: Multiplicity} {o :: Multiplicity} (a :: TYPE q) (b :: TYPE r) (c :: TYPE s). (a %n -> b %o -> c) -> b %o -> a %n -> c

magicDict :: a

magicDict is a special-purpose placeholder value. It is used internally by modules such as GHC.TypeNats to cast a typeclass dictionary with a single method. It is eliminated by a rule during compilation. For the details, see Note [magicDictId magic] in GHC.

proxy# :: forall {k} (a :: k). Proxy# a

Witness for an unboxed Proxy# value, which has no runtime representation.

data Addr# :: TYPE 'AddrRep

An arbitrary machine address assumed to point outside the garbage-collected heap.

data Array# a :: UnliftedType

data ByteArray# :: UnliftedType

A boxed, unlifted datatype representing a region of raw memory in the garbage-collected heap, which is not scanned for pointers during garbage collection.

It is created by freezing a 'MutableByteArray#' with 'unsafeFreezeByteArray#'. Freezing is essentially a no-op, as MutableByteArray# and ByteArray# share the same heap structure under the hood.

The immutable and mutable variants are commonly used for scenarios requiring high-performance data structures, like Text, Primitive Vector, Unboxed Array, and ShortByteString.

Another application of fundamental importance is 'Integer', which is backed by 'ByteArray#'.

The representation on the heap of a Byte Array is:

+------------+-----------------+-----------------------+
|            |                 |                       |
|   HEADER   | SIZE (in bytes) |       PAYLOAD         |
|            |                 |                       |
+------------+-----------------+-----------------------+

To obtain a pointer to actual payload (e.g., for FFI purposes) use 'byteArrayContents#' or 'mutableByteArrayContents#'.

Alternatively, enabling the UnliftedFFITypes extension allows to mention 'ByteArray#' and 'MutableByteArray#' in FFI type signatures directly.

data Char# :: TYPE 'WordRep

data Double# :: TYPE 'DoubleRep

data Float# :: TYPE 'FloatRep

data Int# :: TYPE 'IntRep

data Int8# :: TYPE 'Int8Rep

data Int16# :: TYPE 'Int16Rep

data Int32# :: TYPE 'Int32Rep

data Int64# :: TYPE 'Int64Rep

data Weak# a :: UnliftedType

data MutableArray# a b :: UnliftedType

data MutableByteArray# a :: UnliftedType

A mutable ByteAray#. It can be created in three ways:

• 'newByteArray#': Create an unpinned array.
• 'newPinnedByteArray#': This will create a pinned array,
• 'newAlignedPinnedByteArray#': This will create a pinned array, with a custom alignment.

Unpinned arrays can be moved around during garbage collection, so you must not store or pass pointers to these values if there is a chance for the garbage collector to kick in. That said, even unpinned arrays can be passed to unsafe FFI calls, because no garbage collection happens during these unsafe calls (see Guaranteed Call Safety in the GHC Manual). For safe FFI calls, byte arrays must be not only pinned, but also kept alive by means of the keepAlive# function for the duration of a call (that's because garbage collection cannot move a pinned array, but is free to scrap it altogether).

data MVar# a b :: UnliftedType

A shared mutable variable (not the same as a MutVar#!). (Note: in a non-concurrent implementation, (MVar# a) can be represented by (MutVar# (Maybe a)).)

data IOPort# a b :: UnliftedType

A shared I/O port is almost the same as a MVar#!). The main difference is that IOPort has no deadlock detection or deadlock breaking code that forcibly releases the lock.

data RealWorld

RealWorld is deeply magical. It is primitive, but it is not unlifted (hence ptrArg). We never manipulate values of type RealWorld; it's only used in the type system, to parameterise State#.

data StablePtr# a :: TYPE 'AddrRep

data ArrayArray# :: UnliftedType

data MutableArrayArray# a :: UnliftedType

data State# a :: TYPE ('TupleRep ('[] :: [RuntimeRep]))

State# is the primitive, unlifted type of states. It has one type parameter, thus State# RealWorld, or State# s, where s is a type variable. The only purpose of the type parameter is to keep different state threads separate. It is represented by nothing at all.

data StableName# a :: UnliftedType

data MutVar# a b :: UnliftedType

A MutVar# behaves like a single-element mutable array.

data Word# :: TYPE 'WordRep

data Word8# :: TYPE 'Word8Rep

data Word16# :: TYPE 'Word16Rep

data Word32# :: TYPE 'Word32Rep

data Word64# :: TYPE 'Word64Rep

data ThreadId# :: UnliftedType

(In a non-concurrent implementation, this can be a singleton type, whose (unique) value is returned by myThreadId#. The other operations can be omitted.)

data BCO

Primitive bytecode type.

data TVar# a b :: UnliftedType

data Compact# :: UnliftedType

data Proxy# (a :: k) :: TYPE ('TupleRep ('[] :: [RuntimeRep]))

The type constructor Proxy# is used to bear witness to some type variable. It's used when you want to pass around proxy values for doing things like modelling type applications. A Proxy# is not only unboxed, it also has a polymorphic kind, and has no runtime representation, being totally free.

data SmallArray# a :: UnliftedType

data SmallMutableArray# a b :: UnliftedType

data Int8X16# :: TYPE ('VecRep 'Vec16 'Int8ElemRep)

Warning: this is only available on LLVM.

data Int16X8# :: TYPE ('VecRep 'Vec8 'Int16ElemRep)

Warning: this is only available on LLVM.

data Int32X4# :: TYPE ('VecRep 'Vec4 'Int32ElemRep)

Warning: this is only available on LLVM.

data Int64X2# :: TYPE ('VecRep 'Vec2 'Int64ElemRep)

Warning: this is only available on LLVM.

data Int8X32# :: TYPE ('VecRep 'Vec32 'Int8ElemRep)

Warning: this is only available on LLVM.

data Int16X16# :: TYPE ('VecRep 'Vec16 'Int16ElemRep)

Warning: this is only available on LLVM.

data Int32X8# :: TYPE ('VecRep 'Vec8 'Int32ElemRep)

Warning: this is only available on LLVM.

data Int64X4# :: TYPE ('VecRep 'Vec4 'Int64ElemRep)

Warning: this is only available on LLVM.

data Int8X64# :: TYPE ('VecRep 'Vec64 'Int8ElemRep)

Warning: this is only available on LLVM.

data Int16X32# :: TYPE ('VecRep 'Vec32 'Int16ElemRep)

Warning: this is only available on LLVM.

data Int32X16# :: TYPE ('VecRep 'Vec16 'Int32ElemRep)

Warning: this is only available on LLVM.

data Int64X8# :: TYPE ('VecRep 'Vec8 'Int64ElemRep)

Warning: this is only available on LLVM.

data Word8X16# :: TYPE ('VecRep 'Vec16 'Word8ElemRep)

Warning: this is only available on LLVM.

data Word16X8# :: TYPE ('VecRep 'Vec8 'Word16ElemRep)

Warning: this is only available on LLVM.

data Word32X4# :: TYPE ('VecRep 'Vec4 'Word32ElemRep)

Warning: this is only available on LLVM.

data Word64X2# :: TYPE ('VecRep 'Vec2 'Word64ElemRep)

Warning: this is only available on LLVM.

data Word8X32# :: TYPE ('VecRep 'Vec32 'Word8ElemRep)

Warning: this is only available on LLVM.

data Word16X16# :: TYPE ('VecRep 'Vec16 'Word16ElemRep)

Warning: this is only available on LLVM.

data Word32X8# :: TYPE ('VecRep 'Vec8 'Word32ElemRep)

Warning: this is only available on LLVM.

data Word64X4# :: TYPE ('VecRep 'Vec4 'Word64ElemRep)

Warning: this is only available on LLVM.

data Word8X64# :: TYPE ('VecRep 'Vec64 'Word8ElemRep)

Warning: this is only available on LLVM.

data Word16X32# :: TYPE ('VecRep 'Vec32 'Word16ElemRep)

Warning: this is only available on LLVM.

data Word32X16# :: TYPE ('VecRep 'Vec16 'Word32ElemRep)

Warning: this is only available on LLVM.

data Word64X8# :: TYPE ('VecRep 'Vec8 'Word64ElemRep)

Warning: this is only available on LLVM.

data FloatX4# :: TYPE ('VecRep 'Vec4 'FloatElemRep)

Warning: this is only available on LLVM.

data DoubleX2# :: TYPE ('VecRep 'Vec2 'DoubleElemRep)

Warning: this is only available on LLVM.

data FloatX8# :: TYPE ('VecRep 'Vec8 'FloatElemRep)

Warning: this is only available on LLVM.

data DoubleX4# :: TYPE ('VecRep 'Vec4 'DoubleElemRep)

Warning: this is only available on LLVM.

data FloatX16# :: TYPE ('VecRep 'Vec16 'FloatElemRep)

Warning: this is only available on LLVM.

data DoubleX8# :: TYPE ('VecRep 'Vec8 'DoubleElemRep)

Warning: this is only available on LLVM.

gtChar# :: Char# -> Char# -> Int#

geChar# :: Char# -> Char# -> Int#

eqChar# :: Char# -> Char# -> Int#

neChar# :: Char# -> Char# -> Int#

ltChar# :: Char# -> Char# -> Int#

leChar# :: Char# -> Char# -> Int#

ord# :: Char# -> Int#

int8ToInt# :: Int8# -> Int#

intToInt8# :: Int# -> Int8#

negateInt8# :: Int8# -> Int8#

plusInt8# :: Int8# -> Int8# -> Int8#

subInt8# :: Int8# -> Int8# -> Int8#

timesInt8# :: Int8# -> Int8# -> Int8#

quotInt8# :: Int8# -> Int8# -> Int8#

Warning: this can fail with an unchecked exception.

remInt8# :: Int8# -> Int8# -> Int8#

Warning: this can fail with an unchecked exception.

quotRemInt8# :: Int8# -> Int8# -> (# Int8#, Int8# #)

Warning: this can fail with an unchecked exception.

uncheckedShiftLInt8# :: Int8# -> Int# -> Int8#

uncheckedShiftRAInt8# :: Int8# -> Int# -> Int8#

uncheckedShiftRLInt8# :: Int8# -> Int# -> Int8#

int8ToWord8# :: Int8# -> Word8#

eqInt8# :: Int8# -> Int8# -> Int#

geInt8# :: Int8# -> Int8# -> Int#

gtInt8# :: Int8# -> Int8# -> Int#

leInt8# :: Int8# -> Int8# -> Int#

ltInt8# :: Int8# -> Int8# -> Int#

neInt8# :: Int8# -> Int8# -> Int#

word8ToWord# :: Word8# -> Word#

wordToWord8# :: Word# -> Word8#

plusWord8# :: Word8# -> Word8# -> Word8#

subWord8# :: Word8# -> Word8# -> Word8#

timesWord8# :: Word8# -> Word8# -> Word8#

quotWord8# :: Word8# -> Word8# -> Word8#

Warning: this can fail with an unchecked exception.

remWord8# :: Word8# -> Word8# -> Word8#

Warning: this can fail with an unchecked exception.

quotRemWord8# :: Word8# -> Word8# -> (# Word8#, Word8# #)

Warning: this can fail with an unchecked exception.

andWord8# :: Word8# -> Word8# -> Word8#

orWord8# :: Word8# -> Word8# -> Word8#

xorWord8# :: Word8# -> Word8# -> Word8#

notWord8# :: Word8# -> Word8#

uncheckedShiftLWord8# :: Word8# -> Int# -> Word8#

uncheckedShiftRLWord8# :: Word8# -> Int# -> Word8#

word8ToInt8# :: Word8# -> Int8#

eqWord8# :: Word8# -> Word8# -> Int#

geWord8# :: Word8# -> Word8# -> Int#

gtWord8# :: Word8# -> Word8# -> Int#

leWord8# :: Word8# -> Word8# -> Int#

ltWord8# :: Word8# -> Word8# -> Int#

neWord8# :: Word8# -> Word8# -> Int#

int16ToInt# :: Int16# -> Int#

intToInt16# :: Int# -> Int16#

negateInt16# :: Int16# -> Int16#

plusInt16# :: Int16# -> Int16# -> Int16#

subInt16# :: Int16# -> Int16# -> Int16#

timesInt16# :: Int16# -> Int16# -> Int16#

quotInt16# :: Int16# -> Int16# -> Int16#

Warning: this can fail with an unchecked exception.

remInt16# :: Int16# -> Int16# -> Int16#

Warning: this can fail with an unchecked exception.

quotRemInt16# :: Int16# -> Int16# -> (# Int16#, Int16# #)

Warning: this can fail with an unchecked exception.

uncheckedShiftLInt16# :: Int16# -> Int# -> Int16#

uncheckedShiftRAInt16# :: Int16# -> Int# -> Int16#

uncheckedShiftRLInt16# :: Int16# -> Int# -> Int16#

int16ToWord16# :: Int16# -> Word16#

eqInt16# :: Int16# -> Int16# -> Int#

geInt16# :: Int16# -> Int16# -> Int#

gtInt16# :: Int16# -> Int16# -> Int#

leInt16# :: Int16# -> Int16# -> Int#

ltInt16# :: Int16# -> Int16# -> Int#

neInt16# :: Int16# -> Int16# -> Int#

word16ToWord# :: Word16# -> Word#

wordToWord16# :: Word# -> Word16#

plusWord16# :: Word16# -> Word16# -> Word16#

subWord16# :: Word16# -> Word16# -> Word16#

timesWord16# :: Word16# -> Word16# -> Word16#

quotWord16# :: Word16# -> Word16# -> Word16#

Warning: this can fail with an unchecked exception.

remWord16# :: Word16# -> Word16# -> Word16#

Warning: this can fail with an unchecked exception.

quotRemWord16# :: Word16# -> Word16# -> (# Word16#, Word16# #)

Warning: this can fail with an unchecked exception.

andWord16# :: Word16# -> Word16# -> Word16#

orWord16# :: Word16# -> Word16# -> Word16#

xorWord16# :: Word16# -> Word16# -> Word16#

notWord16# :: Word16# -> Word16#

uncheckedShiftLWord16# :: Word16# -> Int# -> Word16#

uncheckedShiftRLWord16# :: Word16# -> Int# -> Word16#

word16ToInt16# :: Word16# -> Int16#

eqWord16# :: Word16# -> Word16# -> Int#

geWord16# :: Word16# -> Word16# -> Int#

gtWord16# :: Word16# -> Word16# -> Int#

leWord16# :: Word16# -> Word16# -> Int#

ltWord16# :: Word16# -> Word16# -> Int#

neWord16# :: Word16# -> Word16# -> Int#

int32ToInt# :: Int32# -> Int#

intToInt32# :: Int# -> Int32#

negateInt32# :: Int32# -> Int32#

plusInt32# :: Int32# -> Int32# -> Int32#

subInt32# :: Int32# -> Int32# -> Int32#

timesInt32# :: Int32# -> Int32# -> Int32#

quotInt32# :: Int32# -> Int32# -> Int32#

Warning: this can fail with an unchecked exception.

remInt32# :: Int32# -> Int32# -> Int32#

Warning: this can fail with an unchecked exception.

quotRemInt32# ::