Copyright	(c) The University of Glasgow 2002
License	see libraries/base/LICENSE
Maintainer	cvs-ghc@haskell.org
Stability	internal
Portability	non-portable (GHC Extensions)
Safe Haskell	Unsafe
Language	Haskell2010

GHC.Exts

Contents

Representations of some basic types
The maximum tuple size
Primitive operations
Compat wrapper
Resize functions
Fusion
Overloaded string literals
Debugging
Ids with special behaviour
Running RealWorld state thread
Safe coercions
Equality
Representation polymorphism
Transform comprehensions
Event logging
SpecConstr annotations
The call stack
The Constraint kind
The Any type
Overloaded lists

Description

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

Note: no other base module should import this module.

Synopsis

data Int = I# Int#
data Word = W# Word#
data Float = F# Float#
data Double = D# Double#
data Char = C# Char#
data Ptr a = Ptr Addr#
data FunPtr a = FunPtr Addr#
maxTupleSize :: Int
seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b
realWorld# :: State# RealWorld
void# :: Void#
unsafeCoerce# :: forall (k0 :: RuntimeRep) (k1 :: RuntimeRep) (a :: TYPE k0) (b :: TYPE k1). a -> b
nullAddr# :: Addr#
magicDict :: a
proxy# :: forall k (a :: k). Proxy# a
data Addr# :: TYPE 'AddrRep
data Array# a :: TYPE 'UnliftedRep
data ByteArray# :: TYPE 'UnliftedRep
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 :: TYPE 'UnliftedRep
data MutableArray# a b :: TYPE 'UnliftedRep
data MutableByteArray# a :: TYPE 'UnliftedRep
data MVar# a b :: TYPE 'UnliftedRep
data RealWorld
data StablePtr# a :: TYPE 'AddrRep
data ArrayArray# :: TYPE 'UnliftedRep
data MutableArrayArray# a :: TYPE 'UnliftedRep
data State# a :: TYPE ('TupleRep ('[] :: [RuntimeRep]))
data StableName# a :: TYPE 'UnliftedRep
data MutVar# a b :: TYPE 'UnliftedRep
data Void# :: TYPE ('TupleRep ('[] :: [RuntimeRep]))
data Word# :: TYPE 'WordRep
data Word8# :: TYPE 'Word8Rep
data Word16# :: TYPE 'Word16Rep
data Word32# :: TYPE 'Word32Rep
data Word64# :: TYPE 'Word64Rep
data ThreadId# :: TYPE 'UnliftedRep
data BCO# :: TYPE 'UnliftedRep
data TVar# a b :: TYPE 'UnliftedRep
data Compact# :: TYPE 'UnliftedRep
data Proxy# (a :: k) :: TYPE ('TupleRep ('[] :: [RuntimeRep]))
data SmallArray# a :: TYPE 'UnliftedRep
data SmallMutableArray# a b :: TYPE 'UnliftedRep
data Int8X16# :: TYPE ('VecRep 'Vec16 'Int8ElemRep)
data Int16X8# :: TYPE ('VecRep 'Vec8 'Int16ElemRep)
data Int32X4# :: TYPE ('VecRep 'Vec4 'Int32ElemRep)
data Int64X2# :: TYPE ('VecRep 'Vec2 'Int64ElemRep)
data Int8X32# :: TYPE ('VecRep 'Vec32 'Int8ElemRep)
data Int16X16# :: TYPE ('VecRep 'Vec16 'Int16ElemRep)
data Int32X8# :: TYPE ('VecRep 'Vec8 'Int32ElemRep)
data Int64X4# :: TYPE ('VecRep 'Vec4 'Int64ElemRep)
data Int8X64# :: TYPE ('VecRep 'Vec64 'Int8ElemRep)
data Int16X32# :: TYPE ('VecRep 'Vec32 'Int16ElemRep)
data Int32X16# :: TYPE ('VecRep 'Vec16 'Int32ElemRep)
data Int64X8# :: TYPE ('VecRep 'Vec8 'Int64ElemRep)
data Word8X16# :: TYPE ('VecRep 'Vec16 'Word8ElemRep)
data Word16X8# :: TYPE ('VecRep 'Vec8 'Word16ElemRep)
data Word32X4# :: TYPE ('VecRep 'Vec4 'Word32ElemRep)
data Word64X2# :: TYPE ('VecRep 'Vec2 'Word64ElemRep)
data Word8X32# :: TYPE ('VecRep 'Vec32 'Word8ElemRep)
data Word16X16# :: TYPE ('VecRep 'Vec16 'Word16ElemRep)
data Word32X8# :: TYPE ('VecRep 'Vec8 'Word32ElemRep)
data Word64X4# :: TYPE ('VecRep 'Vec4 'Word64ElemRep)
data Word8X64# :: TYPE ('VecRep 'Vec64 'Word8ElemRep)
data Word16X32# :: TYPE ('VecRep 'Vec32 'Word16ElemRep)
data Word32X16# :: TYPE ('VecRep 'Vec16 'Word32ElemRep)
data Word64X8# :: TYPE ('VecRep 'Vec8 'Word64ElemRep)
data FloatX4# :: TYPE ('VecRep 'Vec4 'FloatElemRep)
data DoubleX2# :: TYPE ('VecRep 'Vec2 'DoubleElemRep)
data FloatX8# :: TYPE ('VecRep 'Vec8 'FloatElemRep)
data DoubleX4# :: TYPE ('VecRep 'Vec4 'DoubleElemRep)
data FloatX16# :: TYPE ('VecRep 'Vec16 'FloatElemRep)
data DoubleX8# :: TYPE ('VecRep 'Vec8 'DoubleElemRep)
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#
(+#) :: Int# -> Int# -> Int#
(-#) :: Int# -> Int# -> Int#
(*#) :: Int# -> Int# -> Int#
mulIntMayOflo# :: Int# -> Int# -> Int#
quotInt# :: Int# -> Int# -> Int#
remInt# :: Int# -> Int# -> Int#
quotRemInt# :: Int# -> Int# -> (# Int#, Int# #)
andI# :: Int# -> Int# -> Int#
orI# :: Int# -> Int# -> Int#
xorI# :: Int# -> Int# -> Int#
notI# :: Int# -> Int#
negateInt# :: Int# -> Int#
addIntC# :: Int# -> Int# -> (# Int#, Int# #)
subIntC# :: Int# -> Int# -> (# Int#, Int# #)
(>#) :: Int# -> Int# -> Int#
(>=#) :: Int# -> Int# -> Int#
(==#) :: Int# -> Int# -> Int#
(/=#) :: Int# -> Int# -> Int#
(<#) :: Int# -> Int# -> Int#
(<=#) :: Int# -> Int# -> Int#
chr# :: Int# -> Char#
int2Word# :: Int# -> Word#
int2Float# :: Int# -> Float#
int2Double# :: Int# -> Double#
word2Float# :: Word# -> Float#
word2Double# :: Word# -> Double#
uncheckedIShiftL# :: Int# -> Int# -> Int#
uncheckedIShiftRA# :: Int# -> Int# -> Int#
uncheckedIShiftRL# :: Int# -> Int# -> Int#
extendInt8# :: Int8# -> Int#
narrowInt8# :: Int# -> Int8#
negateInt8# :: Int8# -> Int8#
plusInt8# :: Int8# -> Int8# -> Int8#
subInt8# :: Int8# -> Int8# -> Int8#
timesInt8# :: Int8# -> Int8# -> Int8#
quotInt8# :: Int8# -> Int8# -> Int8#
remInt8# :: Int8# -> Int8# -> Int8#
quotRemInt8# :: Int8# -> Int8# -> (# Int8#, Int8# #)
eqInt8# :: Int8# -> Int8# -> Int#
geInt8# :: Int8# -> Int8# -> Int#
gtInt8# :: Int8# -> Int8# -> Int#
leInt8# :: Int8# -> Int8# -> Int#
ltInt8# :: Int8# -> Int8# -> Int#
neInt8# :: Int8# -> Int8# -> Int#
extendWord8# :: Word8# -> Word#
narrowWord8# :: Word# -> Word8#
notWord8# :: Word8# -> Word8#
plusWord8# :: Word8# -> Word8# -> Word8#
subWord8# :: Word8# -> Word8# -> Word8#
timesWord8# :: Word8# -> Word8# -> Word8#
quotWord8# :: Word8# -> Word8# -> Word8#
remWord8# :: Word8# -> Word8# -> Word8#
quotRemWord8# :: Word8# -> Word8# -> (# Word8#, Word8# #)
eqWord8# :: Word8# -> Word8# -> Int#
geWord8# :: Word8# -> Word8# -> Int#
gtWord8# :: Word8# -> Word8# -> Int#
leWord8# :: Word8# -> Word8# -> Int#
ltWord8# :: Word8# -> Word8# -> Int#
neWord8# :: Word8# -> Word8# -> Int#
extendInt16# :: Int16# -> Int#
narrowInt16# :: Int# -> Int16#
negateInt16# :: Int16# -> Int16#
plusInt16# :: Int16# -> Int16# -> Int16#
subInt16# :: Int16# -> Int16# -> Int16#
timesInt16# :: Int16# -> Int16# -> Int16#
quotInt16# :: Int16# -> Int16# -> Int16#
remInt16# :: Int16# -> Int16# -> Int16#
quotRemInt16# :: Int16# -> Int16# -> (# Int16#, Int16# #)
eqInt16# :: Int16# -> Int16# -> Int#
geInt16# :: Int16# -> Int16# -> Int#
gtInt16# :: Int16# -> Int16# -> Int#
leInt16# :: Int16# -> Int16# -> Int#
ltInt16# :: Int16# -> Int16# -> Int#
neInt16# :: Int16# -> Int16# -> Int#
extendWord16# :: Word16# -> Word#
narrowWord16# :: Word# -> Word16#
notWord16# :: Word16# -> Word16#
plusWord16# :: Word16# -> Word16# -> Word16#
subWord16# :: Word16# -> Word16# -> Word16#
timesWord16# :: Word16# -> Word16# -> Word16#
quotWord16# :: Word16# -> Word16# -> Word16#
remWord16# :: Word16# -> Word16# -> Word16#
quotRemWord16# :: Word16# -> Word16# -> (# Word16#, Word16# #)
eqWord16# :: Word16# -> Word16# -> Int#
geWord16# :: Word16# -> Word16# -> Int#
gtWord16# :: Word16# -> Word16# -> Int#
leWord16# :: Word16# -> Word16# -> Int#
ltWord16# :: Word16# -> Word16# -> Int#
neWord16# :: Word16# -> Word16# -> Int#
plusWord# :: Word# -> Word# -> Word#
addWordC# :: Word# -> Word# -> (# Word#, Int# #)
subWordC# :: Word# -> Word# -> (# Word#, Int# #)
plusWord2# :: Word# -> Word# -> (# Word#, Word# #)
minusWord# :: Word# -> Word# -> Word#
timesWord# :: Word# -> Word# -> Word#
timesWord2# :: Word# -> Word# -> (# Word#, Word# #)
quotWord# :: Word# -> Word# -> Word#
remWord# :: Word# -> Word# -> Word#
quotRemWord# :: Word# -> Word# -> (# Word#, Word# #)
quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#, Word# #)
and# :: Word# -> Word# -> Word#
or# :: Word# -> Word# -> Word#
xor# :: Word# -> Word# -> Word#
not# :: Word# -> Word#
uncheckedShiftL# :: Word# -> Int# -> Word#
uncheckedShiftRL# :: Word# -> Int# -> Word#
word2Int# :: Word# -> Int#
gtWord# :: Word# -> Word# -> Int#
geWord# :: Word# -> Word# -> Int#
eqWord# :: Word# -> Word# -> Int#
neWord# :: Word# -> Word# -> Int#
ltWord# :: Word# -> Word# -> Int#
leWord# :: Word# -> Word# -> Int#
popCnt8# :: Word# -> Word#
popCnt16# :: Word# -> Word#
popCnt32# :: Word# -> Word#
popCnt64# :: Word# -> Word#
popCnt# :: Word# -> Word#
pdep8# :: Word# -> Word# -> Word#
pdep16# :: Word# -> Word# -> Word#
pdep32# :: Word# -> Word# -> Word#
pdep64# :: Word# -> Word# -> Word#
pdep# :: Word# -> Word# -> Word#
pext8# :: Word# -> Word# -> Word#
pext16# :: Word# -> Word# -> Word#
pext32# :: Word# -> Word# -> Word#
pext64# :: Word# -> Word# -> Word#
pext# :: Word# -> Word# -> Word#
clz8# :: Word# -> Word#
clz16# :: Word# -> Word#
clz32# :: Word# -> Word#
clz64# :: Word# -> Word#
clz# :: Word# -> Word#
ctz8# :: Word# -> Word#
ctz16# :: Word# -> Word#
ctz32# :: Word# -> Word#
ctz64# :: Word# -> Word#
ctz# :: Word# -> Word#
byteSwap16# :: Word# -> Word#
byteSwap32# :: Word# -> Word#
byteSwap64# :: Word# -> Word#
byteSwap# :: Word# -> Word#
bitReverse8# :: Word# -> Word#
bitReverse16# :: Word# -> Word#
bitReverse32# :: Word# -> Word#
bitReverse64# :: Word# -> Word#
bitReverse# :: Word# -> Word#
narrow8Int# :: Int# -> Int#
narrow16Int# :: Int# -> Int#
narrow32Int# :: Int# -> Int#
narrow8Word# :: Word# -> Word#
narrow16Word# :: Word# -> Word#
narrow32Word# :: Word# -> Word#
(>##) :: Double# -> Double# -> Int#
(>=##) :: Double# -> Double# -> Int#
(==##) :: Double# -> Double# -> Int#
(/=##) :: Double# -> Double# -> Int#
(<##) :: Double# -> Double# -> Int#
(<=##) :: Double# -> Double# -> Int#
(+##) :: Double# -> Double# -> Double#
(-##) :: Double# -> Double# -> Double#
(*##) :: Double# -> Double# -> Double#
(/##) :: Double# -> Double# -> Double#
negateDouble# :: Double# -> Double#
fabsDouble# :: Double# -> Double#
double2Int# :: Double# -> Int#
double2Float# :: Double# -> Float#
expDouble# :: Double# -> Double#
expm1Double# :: Double# -> Double#
logDouble# :: Double# -> Double#
log1pDouble# :: Double# -> Double#
sqrtDouble# :: Double# -> Double#
sinDouble# :: Double# -> Double#
cosDouble# :: Double# -> Double#
tanDouble# :: Double# -> Double#
asinDouble# :: Double# -> Double#
acosDouble# :: Double# -> Double#
atanDouble# :: Double# -> Double#
sinhDouble# :: Double# -> Double#
coshDouble# :: Double# -> Double#
tanhDouble# :: Double# -> Double#
asinhDouble# :: Double# -> Double#
acoshDouble# :: Double# -> Double#
atanhDouble# :: Double# -> Double#
(**##) :: Double# -> Double# -> Double#
decodeDouble_2Int# :: Double# -> (# Int#, Word#, Word#, Int# #)
decodeDouble_Int64# :: Double# -> (# Int#, Int# #)
gtFloat# :: Float# -> Float# -> Int#
geFloat# :: Float# -> Float# -> Int#
eqFloat# :: Float# -> Float# -> Int#
neFloat# :: Float# -> Float# -> Int#
ltFloat# :: Float# -> Float# -> Int#
leFloat# :: Float# -> Float# -> Int#
plusFloat# :: Float# -> Float# -> Float#
minusFloat# :: Float# -> Float# -> Float#
timesFloat# :: Float# -> Float# -> Float#
divideFloat# :: Float# -> Float# -> Float#
negateFloat# :: Float# -> Float#
fabsFloat# :: Float# -> Float#
float2Int# :: Float# -> Int#
expFloat# :: Float# -> Float#
expm1Float# :: Float# -> Float#
logFloat# :: Float# -> Float#
log1pFloat# :: Float# -> Float#
sqrtFloat# :: Float# -> Float#
sinFloat# :: Float# -> Float#
cosFloat# :: Float# -> Float#
tanFloat# :: Float# -> Float#
asinFloat# :: Float# -> Float#
acosFloat# :: Float# -> Float#
atanFloat# :: Float# -> Float#
sinhFloat# :: Float# -> Float#
coshFloat# :: Float# -> Float#
tanhFloat# :: Float# -> Float#
asinhFloat# :: Float# -> Float#
acoshFloat# :: Float# -> Float#
atanhFloat# :: Float# -> Float#
powerFloat# :: Float# -> Float# -> Float#
float2Double# :: Float# -> Double#
decodeFloat_Int# :: Float# -> (# Int#, Int# #)
newArray# :: Int# -> a -> State# d -> (# State# d, MutableArray# d a #)
sameMutableArray# :: MutableArray# d a -> MutableArray# d a -> Int#
readArray# :: MutableArray# d a -> Int# -> State# d -> (# State# d, a #)
writeArray# :: MutableArray# d a -> Int# -> a -> State# d -> State# d
sizeofArray# :: Array# a -> Int#
sizeofMutableArray# :: MutableArray# d a -> Int#
indexArray# :: Array# a -> Int# -> (# a #)
unsafeFreezeArray# :: MutableArray# d a -> State# d -> (# State# d, Array# a #)
unsafeThawArray# :: Array# a -> State# d -> (# State# d, MutableArray# d a #)
copyArray# :: Array# a -> Int# -> MutableArray# d a -> Int# -> Int# -> State# d -> State# d
copyMutableArray# :: MutableArray# d a -> Int# -> MutableArray# d a -> Int# -> Int# -> State# d -> State# d
cloneArray# :: Array# a -> Int# -> Int# -> Array# a
cloneMutableArray# :: MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
freezeArray# :: MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, Array# a #)
thawArray# :: Array# a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
casArray# :: MutableArray# d a -> Int# -> a -> a -> State# d -> (# State# d, Int#, a #)
newSmallArray# :: Int# -> a -> State# d -> (# State# d, SmallMutableArray# d a #)
sameSmallMutableArray# :: SmallMutableArray# d a -> SmallMutableArray# d a -> Int#
shrinkSmallMutableArray# :: SmallMutableArray# d a -> Int# -> State# d -> State# d
readSmallArray# :: SmallMutableArray# d a -> Int# -> State# d -> (# State# d, a #)
writeSmallArray# :: SmallMutableArray# d a -> Int# -> a -> State# d -> State# d
sizeofSmallArray# :: SmallArray# a -> Int#
sizeofSmallMutableArray# :: SmallMutableArray# d a -> Int#
getSizeofSmallMutableArray# :: SmallMutableArray# d a -> State# d -> (# State# d, Int# #)
indexSmallArray# :: SmallArray# a -> Int# -> (# a #)
unsafeFreezeSmallArray# :: SmallMutableArray# d a -> State# d -> (# State# d, SmallArray# a #)
unsafeThawSmallArray# :: SmallArray# a -> State# d -> (# State# d, SmallMutableArray# d a #)
copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# d a -> Int# -> Int# -> State# d -> State# d
copySmallMutableArray# :: SmallMutableArray# d a -> Int# -> SmallMutableArray# d a -> Int# -> Int# -> State# d -> State# d
cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a
cloneSmallMutableArray# :: SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)
freezeSmallArray# :: SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallArray# a #)
thawSmallArray# :: SmallArray# a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)
casSmallArray# :: SmallMutableArray# d a -> Int# -> a -> a -> State# d -> (# State# d, Int#, a #)
newByteArray# :: Int# -> State# d -> (# State# d, MutableByteArray# d #)
newPinnedByteArray# :: Int# -> State# d -> (# State# d, MutableByteArray# d #)
newAlignedPinnedByteArray# :: Int# -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
isMutableByteArrayPinned# :: MutableByteArray# d -> Int#
isByteArrayPinned# :: ByteArray# -> Int#
byteArrayContents# :: ByteArray# -> Addr#
sameMutableByteArray# :: MutableByteArray# d -> MutableByteArray# d -> Int#
shrinkMutableByteArray# :: MutableByteArray# d -> Int# -> State# d -> State# d
resizeMutableByteArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
unsafeFreezeByteArray# :: MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
sizeofByteArray# :: ByteArray# -> Int#
sizeofMutableByteArray# :: MutableByteArray# d -> Int#
getSizeofMutableByteArray# :: MutableByteArray# d -> State# d -> (# State# d, Int# #)
indexCharArray# :: ByteArray# -> Int# -> Char#
indexWideCharArray# :: ByteArray# -> Int# -> Char#
indexIntArray# :: ByteArray# -> Int# -> Int#
indexWordArray# :: ByteArray# -> Int# -> Word#
indexAddrArray# :: ByteArray# -> Int# -> Addr#
indexFloatArray# :: ByteArray# -> Int# -> Float#
indexDoubleArray# :: ByteArray# -> Int# -> Double#
indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a
indexInt8Array# :: ByteArray# -> Int# -> Int#
indexInt16Array# :: ByteArray# -> Int# -> Int#
indexInt32Array# :: ByteArray# -> Int# -> Int#
indexInt64Array# :: ByteArray# -> Int# -> Int#
indexWord8Array# :: ByteArray# -> Int# -> Word#
indexWord16Array# :: ByteArray# -> Int# -> Word#
indexWord32Array# :: ByteArray# -> Int# -> Word#
indexWord64Array# :: ByteArray# -> Int# -> Word#
indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char#
indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char#
indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr#
indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float#
indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double#
indexWord8ArrayAsStablePtr# :: ByteArray# -> Int# -> StablePtr# a
indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int#
indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int#
indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int#
indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int#
indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word#
indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word#
indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word#
indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word#
readCharArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
readWideCharArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
readIntArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readWordArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readAddrArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
readFloatArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
readDoubleArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readStablePtrArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
readInt8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readInt16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readInt32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readInt64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readWord8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord8ArrayAsChar# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
readWord8ArrayAsWideChar# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
readWord8ArrayAsAddr# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
readWord8ArrayAsFloat# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
readWord8ArrayAsDouble# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readWord8ArrayAsStablePtr# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
readWord8ArrayAsInt16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readWord8ArrayAsInt32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readWord8ArrayAsInt64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readWord8ArrayAsInt# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readWord8ArrayAsWord16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord8ArrayAsWord32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord8ArrayAsWord64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord8ArrayAsWord# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
writeCharArray# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
writeWideCharArray# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
writeIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeWordArray# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeAddrArray# :: MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
writeFloatArray# :: MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeDoubleArray# :: MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeStablePtrArray# :: MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d
writeInt8Array# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeInt16Array# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeInt32Array# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeInt64Array# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeWord8Array# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord16Array# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord32Array# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord64Array# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord8ArrayAsChar# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
writeWord8ArrayAsWideChar# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
writeWord8ArrayAsAddr# :: MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
writeWord8ArrayAsFloat# :: MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeWord8ArrayAsDouble# :: MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeWord8ArrayAsStablePtr# :: MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d
writeWord8ArrayAsInt16# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeWord8ArrayAsInt32# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeWord8ArrayAsInt64# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeWord8ArrayAsInt# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeWord8ArrayAsWord16# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord8ArrayAsWord32# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord8ArrayAsWord64# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord8ArrayAsWord# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
copyMutableByteArray# :: MutableByteArray# d -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# d -> State# d
copyMutableByteArrayToAddr# :: MutableByteArray# d -> Int# -> Addr# -> Int# -> State# d -> State# d
copyAddrToByteArray# :: Addr# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
setByteArray# :: MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> State# d
atomicReadIntArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
atomicWriteIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
casIntArray# :: MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchAddIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchSubIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchAndIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchNandIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchOrIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchXorIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
newArrayArray# :: Int# -> State# d -> (# State# d, MutableArrayArray# d #)
sameMutableArrayArray# :: MutableArrayArray# d -> MutableArrayArray# d -> Int#
unsafeFreezeArrayArray# :: MutableArrayArray# d -> State# d -> (# State# d, ArrayArray# #)
sizeofArrayArray# :: ArrayArray# -> Int#
sizeofMutableArrayArray# :: MutableArrayArray# d -> Int#
indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#
indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#
readByteArrayArray# :: MutableArrayArray# d -> Int# -> State# d -> (# State# d, ByteArray# #)
readMutableByteArrayArray# :: MutableArrayArray# d -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
readArrayArrayArray# :: MutableArrayArray# d -> Int# -> State# d -> (# State# d, ArrayArray# #)
readMutableArrayArrayArray# :: MutableArrayArray# d -> Int# -> State# d -> (# State# d, MutableArrayArray# d #)
writeByteArrayArray# :: MutableArrayArray# d -> Int# -> ByteArray# -> State# d -> State# d
writeMutableByteArrayArray# :: MutableArrayArray# d -> Int# -> MutableByteArray# d -> State# d -> State# d
writeArrayArrayArray# :: MutableArrayArray# d -> Int# -> ArrayArray# -> State# d -> State# d
writeMutableArrayArrayArray# :: MutableArrayArray# d -> Int# -> MutableArrayArray# d -> State# d -> State# d
copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# d -> Int# -> Int# -> State# d -> State# d
copyMutableArrayArray# :: MutableArrayArray# d -> Int# -> MutableArrayArray# d -> Int# -> Int# -> State# d -> State# d
plusAddr# :: Addr# -> Int# -> Addr#
minusAddr# :: Addr# -> Addr# -> Int#
remAddr# :: Addr# -> Int# -> Int#
addr2Int# :: Addr# -> Int#
int2Addr# :: Int# -> Addr#
gtAddr# :: Addr# -> Addr# -> Int#
geAddr# :: Addr# -> Addr# -> Int#
eqAddr# :: Addr# -> Addr# -> Int#
neAddr# :: Addr# -> Addr# -> Int#
ltAddr# :: Addr# -> Addr# -> Int#
leAddr# :: Addr# -> Addr# -> Int#
indexCharOffAddr# :: Addr# -> Int# -> Char#
indexWideCharOffAddr# :: Addr# -> Int# -> Char#
indexIntOffAddr# :: Addr# -> Int# -> Int#
indexWordOffAddr# :: Addr# -> Int# -> Word#
indexAddrOffAddr# :: Addr# -> Int# -> Addr#
indexFloatOffAddr# :: Addr# -> Int# -> Float#
indexDoubleOffAddr# :: Addr# -> Int# -> Double#
indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a
indexInt8OffAddr# :: Addr# -> Int# -> Int#
indexInt16OffAddr# :: Addr# -> Int# -> Int#
indexInt32OffAddr# :: Addr# -> Int# -> Int#
indexInt64OffAddr# :: Addr# -> Int# -> Int#
indexWord8OffAddr# :: Addr# -> Int# -> Word#
indexWord16OffAddr# :: Addr# -> Int# -> Word#
indexWord32OffAddr# :: Addr# -> Int# -> Word#
indexWord64OffAddr# :: Addr# -> Int# -> Word#
readCharOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Char# #)
readWideCharOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Char# #)
readIntOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)
readWordOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)
readAddrOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Addr# #)
readFloatOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Float# #)
readDoubleOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Double# #)
readStablePtrOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)
readInt8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)
readInt16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)
readInt32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)
readInt64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)
readWord8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)
readWord16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)
readWord32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)
readWord64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)
writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# d -> State# d
writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# d -> State# d
writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d
writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d
writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# d -> State# d
writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# d -> State# d
writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# d -> State# d
writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# d -> State# d
writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d
writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d
writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d
writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d
writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d
writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d
writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d
writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d
newMutVar# :: a -> State# d -> (# State# d, MutVar# d a #)
readMutVar# :: MutVar# d a -> State# d -> (# State# d, a #)
writeMutVar# :: MutVar# d a -> a -> State# d -> State# d
sameMutVar# :: MutVar# d a -> MutVar# d a -> Int#
atomicModifyMutVar2# :: MutVar# d a -> (a -> c) -> State# d -> (# State# d, a, c #)
atomicModifyMutVar_# :: MutVar# d a -> (a -> a) -> State# d -> (# State# d, a, a #)
casMutVar# :: MutVar# d a -> a -> a -> State# d -> (# State# d, Int#, a #)
catch# :: (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
raise# :: forall b (q :: RuntimeRep) (a :: TYPE q). b -> a
raiseIO# :: a -> State# RealWorld -> (# State# RealWorld, b #)
maskAsyncExceptions# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
maskUninterruptible# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
unmaskAsyncExceptions# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
getMaskingState# :: State# RealWorld -> (# State# RealWorld, Int# #)
atomically# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
retry# :: State# RealWorld -> (# State# RealWorld, a #)
catchRetry# :: (State# RealWorld -> (# State# RealWorld, a #)) -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
catchSTM# :: (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
newTVar# :: a -> State# d -> (# State# d, TVar# d a #)
readTVar# :: TVar# d a -> State# d -> (# State# d, a #)
readTVarIO# :: TVar# d a -> State# d -> (# State# d, a #)
writeTVar# :: TVar# d a -> a -> State# d -> State# d
sameTVar# :: TVar# d a -> TVar# d a -> Int#
newMVar# :: State# d -> (# State# d, MVar# d a #)
takeMVar# :: MVar# d a -> State# d -> (# State# d, a #)
tryTakeMVar# :: MVar# d a -> State# d -> (# State# d, Int#, a #)
putMVar# :: MVar# d a -> a -> State# d -> State# d
tryPutMVar# :: MVar# d a -> a -> State# d -> (# State# d, Int# #)
readMVar# :: MVar# d a -> State# d -> (# State# d, a #)
tryReadMVar# :: MVar# d a -> State# d -> (# State# d, Int#, a #)
sameMVar# :: MVar# d a -> MVar# d a -> Int#
isEmptyMVar# :: MVar# d a -> State# d -> (# State# d, Int# #)
delay# :: Int# -> State# d -> State# d
waitRead# :: Int# -> State# d -> State# d
waitWrite# :: Int# -> State# d -> State# d
fork# :: a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
forkOn# :: Int# -> a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
killThread# :: ThreadId# -> a -> State# RealWorld -> State# RealWorld
yield# :: State# RealWorld -> State# RealWorld
myThreadId# :: State# RealWorld -> (# State# RealWorld, ThreadId# #)
labelThread# :: ThreadId# -> Addr# -> State# RealWorld -> State# RealWorld
isCurrentThreadBound# :: State# RealWorld -> (# State# RealWorld, Int# #)
noDuplicate# :: State# d -> State# d
threadStatus# :: ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, Int#, Int# #)
mkWeak# :: forall (q :: RuntimeRep) (a :: TYPE q) b c. a -> b -> (State# RealWorld -> (# State# RealWorld, c #)) -> State# RealWorld -> (# State# RealWorld, Weak# b #)
mkWeakNoFinalizer# :: forall (q :: RuntimeRep) (a :: TYPE q) b. a -> b -> State# RealWorld -> (# State# RealWorld, Weak# b #)
addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# RealWorld -> (# State# RealWorld, Int# #)
deRefWeak# :: Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, a #)
finalizeWeak# :: Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, State# RealWorld -> (# State# RealWorld, b #) #)
touch# :: forall (q :: RuntimeRep) (a :: TYPE q). a -> State# RealWorld -> State# RealWorld
makeStablePtr# :: a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)
deRefStablePtr# :: StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)
eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int#
makeStableName# :: a -> State# RealWorld -> (# State# RealWorld, StableName# a #)
eqStableName# :: StableName# a -> StableName# b -> Int#
stableNameToInt# :: StableName# a -> Int#
compactNew# :: Word# -> State# RealWorld -> (# State# RealWorld, Compact# #)
compactResize# :: Compact# -> Word# -> State# RealWorld -> State# RealWorld
compactContains# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, Int# #)
compactContainsAny# :: a -> State# RealWorld -> (# State# RealWorld, Int# #)
compactGetFirstBlock# :: Compact# -> State# RealWorld -> (# State# RealWorld, Addr#, Word# #)
compactGetNextBlock# :: Compact# -> Addr# -> State# RealWorld -> (# State# RealWorld, Addr#, Word# #)
compactAllocateBlock# :: Word# -> Addr# -> State# RealWorld -> (# State# RealWorld, Addr# #)
compactFixupPointers# :: Addr# -> Addr# -> State# RealWorld -> (# State# RealWorld, Compact#, Addr# #)
compactAdd# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, a #)
compactAddWithSharing# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, a #)
compactSize# :: Compact# -> State# RealWorld -> (# State# RealWorld, Word# #)
reallyUnsafePtrEquality# :: a -> a -> Int#
par# :: a -> Int#
spark# :: a -> State# d -> (# State# d, a #)
seq# :: a -> State# d -> (# State# d, a #)
getSpark# :: State# d -> (# State# d, Int#, a #)
numSparks# :: State# d -> (# State# d, Int# #)
dataToTag# :: a -> Int#
tagToEnum# :: Int# -> a
addrToAny# :: Addr# -> (# a #)
anyToAddr# :: a -> State# RealWorld -> (# State# RealWorld, Addr# #)
mkApUpd0# :: BCO# -> (# a #)
newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# d -> (# State# d, BCO# #)
unpackClosure# :: a -> (# Addr#, ByteArray#, Array# b #)
closureSize# :: a -> Int#
getApStackVal# :: a -> Int# -> (# Int#, b #)
getCCSOf# :: a -> State# d -> (# State# d, Addr# #)
getCurrentCCS# :: a -> State# d -> (# State# d, Addr# #)
clearCCS# :: (State# d -> (# State# d, a #)) -> State# d -> (# State# d, a #)
traceEvent# :: Addr# -> State# d -> State# d
traceBinaryEvent# :: Addr# -> Int# -> State# d -> State# d
traceMarker# :: Addr# -> State# d -> State# d
setThreadAllocationCounter# :: Int# -> State# RealWorld -> State# RealWorld
broadcastInt8X16# :: Int# -> Int8X16#
broadcastInt16X8# :: Int# -> Int16X8#
broadcastInt32X4# :: Int# -> Int32X4#
broadcastInt64X2# :: Int# -> Int64X2#
broadcastInt8X32# :: Int# -> Int8X32#
broadcastInt16X16# :: Int# -> Int16X16#
broadcastInt32X8# :: Int# -> Int32X8#
broadcastInt64X4# :: Int# -> Int64X4#
broadcastInt8X64# :: Int# -> Int8X64#
broadcastInt16X32# :: Int# -> Int16X32#
broadcastInt32X16# :: Int# -> Int32X16#
broadcastInt64X8# :: Int# -> Int64X8#
broadcastWord8X16# :: Word# -> Word8X16#
broadcastWord16X8# :: Word# -> Word16X8#
broadcastWord32X4# :: Word# -> Word32X4#
broadcastWord64X2# :: Word# -> Word64X2#
broadcastWord8X32# :: Word# -> Word8X32#
broadcastWord16X16# :: Word# -> Word16X16#
broadcastWord32X8# :: Word# -> Word32X8#
broadcastWord64X4# :: Word# -> Word64X4#
broadcastWord8X64# :: Word# -> Word8X64#
broadcastWord16X32# :: Word# -> Word16X32#
broadcastWord32X16# :: Word# -> Word32X16#
broadcastWord64X8# :: Word# -> Word64X8#
broadcastFloatX4# :: Float# -> FloatX4#
broadcastDoubleX2# :: Double# -> DoubleX2#
broadcastFloatX8# :: Float# -> FloatX8#
broadcastDoubleX4# :: Double# -> DoubleX4#
broadcastFloatX16# :: Float# -> FloatX16#
broadcastDoubleX8# :: Double# -> DoubleX8#
packInt8X16# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X16#
packInt16X8# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X8#
packInt32X4# :: (# Int#, Int#, Int#, Int# #) -> Int32X4#
packInt64X2# :: (# Int#, Int# #) -> Int64X2#
packInt8X32# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X32#
packInt16X16# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X16#
packInt32X8# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int32X8#
packInt64X4# :: (# Int#, Int#, Int#, Int# #) -> Int64X4#
packInt8X64# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X64#
packInt16X32# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X32#
packInt32X16# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int32X16#
packInt64X8# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int64X8#
packWord8X16# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word8X16#
packWord16X8# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word16X8#
packWord32X4# :: (# Word#, Word#, Word#, Word# #) -> Word32X4#
packWord64X2# :: (# Word#, Word# #) -> Word64X2#
packWord8X32# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word8X32#
packWord16X16# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word16X16#
packWord32X8# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word32X8#
packWord64X4# :: (# Word#, Word#, Word#, Word# #) -> Word64X4#
packWord8X64# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word8X64#
packWord16X32# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word16X32#
packWord32X16# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word32X16#
packWord64X8# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word64X8#
packFloatX4# :: (# Float#, Float#, Float#, Float# #) -> FloatX4#
packDoubleX2# :: (# Double#, Double# #) -> DoubleX2#
packFloatX8# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX8#
packDoubleX4# :: (# Double#, Double#, Double#, Double# #) -> DoubleX4#
packFloatX16# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX16#
packDoubleX8# :: (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #) -> DoubleX8#
unpackInt8X16# :: Int8X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt16X8# :: Int16X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt32X4# :: Int32X4# -> (# Int#, Int#, Int#, Int# #)
unpackInt64X2# :: Int64X2# -> (# Int#, Int# #)
unpackInt8X32# :: Int8X32# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt16X16# :: Int16X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt32X8# :: Int32X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt64X4# :: Int64X4# -> (# Int#, Int#, Int#, Int# #)
unpackInt8X64# :: Int8X64# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt16X32# :: Int16X32# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt32X16# :: Int32X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt64X8# :: Int64X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackWord8X16# :: Word8X16# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord16X8# :: Word16X8# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord32X4# :: Word32X4# -> (# Word#, Word#, Word#, Word# #)
unpackWord64X2# :: Word64X2# -> (# Word#, Word# #)
unpackWord8X32# :: Word8X32# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord16X16# :: Word16X16# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord32X8# :: Word32X8# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord64X4# :: Word64X4# -> (# Word#, Word#, Word#, Word# #)
unpackWord8X64# :: Word8X64# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord16X32# :: Word16X32# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord32X16# :: Word32X16# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord64X8# :: Word64X8# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackFloatX4# :: FloatX4# -> (# Float#, Float#, Float#, Float# #)
unpackDoubleX2# :: DoubleX2# -> (# Double#, Double# #)
unpackFloatX8# :: FloatX8# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)
unpackDoubleX4# :: DoubleX4# -> (# Double#, Double#, Double#, Double# #)
unpackFloatX16# :: FloatX16# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)
unpackDoubleX8# :: DoubleX8# -> (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #)
insertInt8X16# :: Int8X16# -> Int# -> Int# -> Int8X16#
insertInt16X8# :: Int16X8# -> Int# -> Int# -> Int16X8#
insertInt32X4# :: Int32X4# -> Int# -> Int# -> Int32X4#
insertInt64X2# :: Int64X2# -> Int# -> Int# -> Int64X2#
insertInt8X32# :: Int8X32# -> Int# -> Int# -> Int8X32#
insertInt16X16# :: Int16X16# -> Int# -> Int# -> Int16X16#
insertInt32X8# :: Int32X8# -> Int# -> Int# -> Int32X8#
insertInt64X4# :: Int64X4# -> Int# -> Int# -> Int64X4#
insertInt8X64# :: Int8X64# -> Int# -> Int# -> Int8X64#
insertInt16X32# :: Int16X32# -> Int# -> Int# -> Int16X32#
insertInt32X16# :: Int32X16# -> Int# -> Int# -> Int32X16#
insertInt64X8# :: Int64X8# -> Int# -> Int# -> Int64X8#
insertWord8X16# :: Word8X16# -> Word# -> Int# -> Word8X16#
insertWord16X8# :: Word16X8# -> Word# -> Int# -> Word16X8#
insertWord32X4# :: Word32X4# -> Word# -> Int# -> Word32X4#
insertWord64X2# :: Word64X2# -> Word# -> Int# -> Word64X2#
insertWord8X32# :: Word8X32# -> Word# -> Int# -> Word8X32#
insertWord16X16# :: Word16X16# -> Word# -> Int# -> Word16X16#
insertWord32X8# :: Word32X8# -> Word# -> Int# -> Word32X8#
insertWord64X4# :: Word64X4# -> Word# -> Int# -> Word64X4#
insertWord8X64# :: Word8X64# -> Word# -> Int# -> Word8X64#
insertWord16X32# :: Word16X32# -> Word# -> Int# -> Word16X32#
insertWord32X16# :: Word32X16# -> Word# -> Int# -> Word32X16#
insertWord64X8# :: Word64X8# -> Word# -> Int# -> Word64X8#
insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4#
insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2#
insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8#
insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4#
insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16#
insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8#
plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
negateInt8X16# :: Int8X16# -> Int8X16#
negateInt16X8# :: Int16X8# -> Int16X8#
negateInt32X4# :: Int32X4# -> Int32X4#
negateInt64X2# :: Int64X2# -> Int64X2#
negateInt8X32# :: Int8X32# -> Int8X32#
negateInt16X16# :: Int16X16# -> Int16X16#
negateInt32X8# :: Int32X8# -> Int32X8#
negateInt64X4# :: Int64X4# -> Int64X4#
negateInt8X64# :: Int8X64# -> Int8X64#
negateInt16X32# :: Int16X32# -> Int16X32#
negateInt32X16# :: Int32X16# -> Int32X16#
negateInt64X8# :: Int64X8# -> Int64X8#
negateFloatX4# :: FloatX4# -> FloatX4#
negateDoubleX2# :: DoubleX2# -> DoubleX2#
negateFloatX8# :: FloatX8# -> FloatX8#
negateDoubleX4# :: DoubleX4# -> DoubleX4#
negateFloatX16# :: FloatX16# -> FloatX16#
negateDoubleX8# :: DoubleX8# -> DoubleX8#
indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16#
indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8#
indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4#
indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2#
indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32#
indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16#
indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8#
indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4#
indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64#
indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32#
indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16#
indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8#
indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16#
indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8#
indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4#
indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2#
indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32#
indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16#
indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8#
indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4#
indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64#
indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32#
indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16#
indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8#
indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4#
indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2#
indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8#
indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4#
indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16#
indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8#
readInt8X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)
readInt16X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)
readInt32X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)
readInt64X2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)
readInt8X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)
readInt16X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)
readInt32X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)
readInt64X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)
readInt8X64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)
readInt16X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)
readInt32X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)
readInt64X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)
readWord8X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)
readWord16X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)
readWord32X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)
readWord64X2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)
readWord8X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)
readWord16X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)
readWord32X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)
readWord64X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)
readWord8X64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)
readWord16X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)
readWord32X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)
readWord64X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)
readFloatX4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)
readDoubleX2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)
readFloatX8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)
readDoubleX4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)
readFloatX16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)
readDoubleX8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)
writeInt8X16Array# :: MutableByteArray# d -> Int# -> Int8X16# -> State# d -> State# d
writeInt16X8Array# :: MutableByteArray# d -> Int# -> Int16X8# -> State# d -> State# d
writeInt32X4Array# :: MutableByteArray# d -> Int# -> Int32X4# -> State# d -> State# d
writeInt64X2Array# :: MutableByteArray# d -> Int# -> Int64X2# -> State# d -> State# d
writeInt8X32Array# :: MutableByteArray# d -> Int# -> Int8X32# -> State# d -> State# d
writeInt16X16Array# :: MutableByteArray# d -> Int# -> Int16X16# -> State# d -> State# d
writeInt32X8Array# :: MutableByteArray# d -> Int# -> Int32X8# -> State# d -> State# d
writeInt64X4Array# :: MutableByteArray# d -> Int# -> Int64X4# -> State# d -> State# d
writeInt8X64Array# :: MutableByteArray# d -> Int# -> Int8X64# -> State# d -> State# d
writeInt16X32Array# :: MutableByteArray# d -> Int# -> Int16X32# -> State# d -> State# d
writeInt32X16Array# :: MutableByteArray# d -> Int# -> Int32X16# -> State# d -> State# d
writeInt64X8Array# :: MutableByteArray# d -> Int# -> Int64X8# -> State# d -> State# d
writeWord8X16Array# :: MutableByteArray# d -> Int# -> Word8X16# -> State# d -> State# d
writeWord16X8Array# :: MutableByteArray# d -> Int# -> Word16X8# -> State# d -> State# d
writeWord32X4Array# :: MutableByteArray# d -> Int# -> Word32X4# -> State# d -> State# d
writeWord64X2Array# :: MutableByteArray# d -> Int# -> Word64X2# -> State# d -> State# d
writeWord8X32Array# :: MutableByteArray# d -> Int# -> Word8X32# -> State# d -> State# d
writeWord16X16Array# :: MutableByteArray# d -> Int# -> Word16X16# -> State# d -> State# d
writeWord32X8Array# :: MutableByteArray# d -> Int# -> Word32X8# -> State# d -> State# d
writeWord64X4Array# :: MutableByteArray# d -> Int# -> Word64X4# -> State# d -> State# d
writeWord8X64Array# :: MutableByteArray# d -> Int# -> Word8X64# -> State# d -> State# d
writeWord16X32Array# :: MutableByteArray# d -> Int# -> Word16X32# -> State# d -> State# d
writeWord32X16Array# :: MutableByteArray# d -> Int# -> Word32X16# -> State# d -> State# d
writeWord64X8Array# :: MutableByteArray# d -> Int# -> Word64X8# -> State# d -> State# d
writeFloatX4Array# :: MutableByteArray# d -> Int# -> FloatX4# -> State# d -> State# d
writeDoubleX2Array# :: MutableByteArray# d -> Int# -> DoubleX2# -> State# d -> State# d
writeFloatX8Array# :: MutableByteArray# d -> Int# -> FloatX8# -> State# d -> State# d
writeDoubleX4Array# :: MutableByteArray# d -> Int# -> DoubleX4# -> State# d -> State# d
writeFloatX16Array# :: MutableByteArray# d -> Int# -> FloatX16# -> State# d -> State# d
writeDoubleX8Array# :: MutableByteArray# d -> Int# -> DoubleX8# -> State# d -> State# d
indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16#
indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8#
indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4#
indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2#
indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32#
indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16#
indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8#
indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4#
indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64#
indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32#
indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16#
indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8#
indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16#
indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8#
indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4#
indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2#
indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32#
indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16#
indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8#
indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4#
indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64#
indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32#
indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16#
indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8#
indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4#
indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2#
indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8#
indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4#
indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16#
indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8#
readInt8X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)
readInt16X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)
readInt32X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)
readInt64X2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)
readInt8X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)
readInt16X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)
readInt32X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)
readInt64X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)
readInt8X64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)
readInt16X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)
readInt32X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)
readInt64X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)
readWord8X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)
readWord16X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)
readWord32X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)
readWord64X2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)
readWord8X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)
readWord16X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)
readWord32X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)
readWord64X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)
readWord8X64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)
readWord16X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)
readWord32X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)
readWord64X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)
readFloatX4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)
readDoubleX2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)
readFloatX8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)
readDoubleX4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)
readFloatX16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)
readDoubleX8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)
writeInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -> State# d -> State# d
writeInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -> State# d -> State# d
writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# d -> State# d
writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# d -> State# d
writeInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -> State# d -> State# d
writeInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -> State# d -> State# d
writeInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -> State# d -> State# d
writeInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -> State# d -> State# d
writeInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -> State# d -> State# d
writeInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -> State# d -> State# d
writeInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -> State# d -> State# d
writeInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -> State# d -> State# d
writeWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -> State# d -> State# d
writeWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -> State# d -> State# d
writeWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -> State# d -> State# d
writeWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -> State# d -> State# d
writeWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -> State# d -> State# d
writeWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -> State# d -> State# d
writeWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -> State# d -> State# d
writeWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -> State# d -> State# d
writeWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -> State# d -> State# d
writeWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -> State# d -> State# d
writeWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -> State# d -> State# d
writeWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -> State# d -> State# d
writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# d -> State# d
writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# d -> State# d
writeFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -> State# d -> State# d
writeDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -> State# d -> State# d
writeFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -> State# d -> State# d
writeDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -> State# d -> State# d
indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16#
indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8#
indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4#
indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2#
indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32#
indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16#
indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8#
indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4#
indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64#
indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32#
indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16#
indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8#
indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16#
indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8#
indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4#
indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2#
indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32#
indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16#
indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8#
indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4#
indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64#
indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32#
indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16#
indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8#
indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4#
indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2#
indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8#
indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4#
indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16#
indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8#
readInt8ArrayAsInt8X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)
readInt16ArrayAsInt16X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)
readInt32ArrayAsInt32X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)
readInt64ArrayAsInt64X2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)
readInt8ArrayAsInt8X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)
readInt16ArrayAsInt16X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)
readInt32ArrayAsInt32X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)
readInt64ArrayAsInt64X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)
readInt8ArrayAsInt8X64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)
readInt16ArrayAsInt16X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)
readInt32ArrayAsInt32X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)
readInt64ArrayAsInt64X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)
readWord8ArrayAsWord8X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)
readWord16ArrayAsWord16X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)
readWord32ArrayAsWord32X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)
readWord64ArrayAsWord64X2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)
readWord8ArrayAsWord8X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)
readWord16ArrayAsWord16X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)
readWord32ArrayAsWord32X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)
readWord64ArrayAsWord64X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)
readWord8ArrayAsWord8X64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)
readWord16ArrayAsWord16X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)
readWord32ArrayAsWord32X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)
readWord64ArrayAsWord64X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)
readFloatArrayAsFloatX4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)
readDoubleArrayAsDoubleX2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)
readFloatArrayAsFloatX8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)
readDoubleArrayAsDoubleX4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)
readFloatArrayAsFloatX16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)
readDoubleArrayAsDoubleX8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)
writeInt8ArrayAsInt8X16# :: MutableByteArray# d -> Int# -> Int8X16# -> State# d -> State# d
writeInt16ArrayAsInt16X8# :: MutableByteArray# d -> Int# -> Int16X8# -> State# d -> State# d
writeInt32ArrayAsInt32X4# :: MutableByteArray# d -> Int# -> Int32X4# -> State# d -> State# d
writeInt64ArrayAsInt64X2# :: MutableByteArray# d -> Int# -> Int64X2# -> State# d -> State# d
writeInt8ArrayAsInt8X32# :: MutableByteArray# d -> Int# -> Int8X32# -> State# d -> State# d
writeInt16ArrayAsInt16X16# :: MutableByteArray# d -> Int# -> Int16X16# -> State# d -> State# d
writeInt32ArrayAsInt32X8# :: MutableByteArray# d -> Int# -> Int32X8# -> State# d -> State# d
writeInt64ArrayAsInt64X4# :: MutableByteArray# d -> Int# -> Int64X4# -> State# d -> State# d
writeInt8ArrayAsInt8X64# :: MutableByteArray# d -> Int# -> Int8X64# -> State# d -> State# d
writeInt16ArrayAsInt16X32# :: MutableByteArray# d -> Int# -> Int16X32# -> State# d -> State# d
writeInt32ArrayAsInt32X16# :: MutableByteArray# d -> Int# -> Int32X16# -> State# d -> State# d
writeInt64ArrayAsInt64X8# :: MutableByteArray# d -> Int# -> Int64X8# -> State# d -> State# d
writeWord8ArrayAsWord8X16# :: MutableByteArray# d -> Int# -> Word8X16# -> State# d -> State# d
writeWord16ArrayAsWord16X8# :: MutableByteArray# d -> Int# -> Word16X8# -> State# d -> State# d
writeWord32ArrayAsWord32X4# :: MutableByteArray# d -> Int# -> Word32X4# -> State# d -> State# d
writeWord64ArrayAsWord64X2# :: MutableByteArray# d -> Int# -> Word64X2# -> State# d -> State# d
writeWord8ArrayAsWord8X32# :: MutableByteArray# d -> Int# -> Word8X32# -> State# d -> State# d
writeWord16ArrayAsWord16X16# :: MutableByteArray# d -> Int# -> Word16X16# -> State# d -> State# d
writeWord32ArrayAsWord32X8# :: MutableByteArray# d -> Int# -> Word32X8# -> State# d -> State# d
writeWord64ArrayAsWord64X4# :: MutableByteArray# d -> Int# -> Word64X4# -> State# d -> State# d
writeWord8ArrayAsWord8X64# :: MutableByteArray# d -> Int# -> Word8X64# -> State# d -> State# d
writeWord16ArrayAsWord16X32# :: MutableByteArray# d -> Int# -> Word16X32# -> State# d -> State# d
writeWord32ArrayAsWord32X16# :: MutableByteArray# d -> Int# -> Word32X16# -> State# d -> State# d
writeWord64ArrayAsWord64X8# :: MutableByteArray# d -> Int# -> Word64X8# -> State# d -> State# d
writeFloatArrayAsFloatX4# :: MutableByteArray# d -> Int# -> FloatX4# -> State# d -> State# d
writeDoubleArrayAsDoubleX2# :: MutableByteArray# d -> Int# -> DoubleX2# -> State# d -> State# d
writeFloatArrayAsFloatX8# :: MutableByteArray# d -> Int# -> FloatX8# -> State# d -> State# d
writeDoubleArrayAsDoubleX4# :: MutableByteArray# d -> Int# -> DoubleX4# -> State# d -> State# d
writeFloatArrayAsFloatX16# :: MutableByteArray# d -> Int# -> FloatX16# -> State# d -> State# d
writeDoubleArrayAsDoubleX8# :: MutableByteArray# d -> Int# -> DoubleX8# -> State# d -> State# d
indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16#
indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8#
indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4#
indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2#
indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32#
indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16#
indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8#
indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4#
indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64#
indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32#
indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16#
indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8#
indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16#
indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8#
indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4#
indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2#
indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32#
indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16#
indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8#
indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4#
indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64#
indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32#
indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16#
indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8#
indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4#
indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2#
indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8#
indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4#
indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16#
indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8#
readInt8OffAddrAsInt8X16# :: Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)
readInt16OffAddrAsInt16X8# :: Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)
readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)
readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)
readInt8OffAddrAsInt8X32# :: Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)
readInt16OffAddrAsInt16X16# :: Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)
readInt32OffAddrAsInt32X8# :: Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)
readInt64OffAddrAsInt64X4# :: Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)
readInt8OffAddrAsInt8X64# :: Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)
readInt16OffAddrAsInt16X32# :: Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)
readInt32OffAddrAsInt32X16# :: Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)
readInt64OffAddrAsInt64X8# :: Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)
readWord8OffAddrAsWord8X16# :: Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)
readWord16OffAddrAsWord16X8# :: Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)
readWord32OffAddrAsWord32X4# :: Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)
readWord64OffAddrAsWord64X2# :: Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)
readWord8OffAddrAsWord8X32# :: Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)
readWord16OffAddrAsWord16X16# :: Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)
readWord32OffAddrAsWord32X8# :: Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)
readWord64OffAddrAsWord64X4# :: Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)
readWord8OffAddrAsWord8X64# :: Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)
readWord16OffAddrAsWord16X32# :: Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)
readWord32OffAddrAsWord32X16# :: Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)
readWord64OffAddrAsWord64X8# :: Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)
readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)
readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)
readFloatOffAddrAsFloatX8# :: Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)
readDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)
readFloatOffAddrAsFloatX16# :: Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)
readDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)
writeInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -> State# d -> State# d
writeInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -> State# d -> State# d
writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# d -> State# d
writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# d -> State# d
writeInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -> State# d -> State# d
writeInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -> State# d -> State# d
writeInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -> State# d -> State# d
writeInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -> State# d -> State# d
writeInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -> State# d -> State# d
writeInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -> State# d -> State# d
writeInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -> State# d -> State# d
writeInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -> State# d -> State# d
writeWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -> State# d -> State# d
writeWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -> State# d -> State# d
writeWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -> State# d -> State# d
writeWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -> State# d -> State# d
writeWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -> State# d -> State# d
writeWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -> State# d -> State# d
writeWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -> State# d -> State# d
writeWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -> State# d -> State# d
writeWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -> State# d -> State# d
writeWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -> State# d -> State# d
writeWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -> State# d -> State# d
writeWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -> State# d -> State# d
writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# d -> State# d
writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# d -> State# d
writeFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -> State# d -> State# d
writeDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -> State# d -> State# d
writeFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -> State# d -> State# d
writeDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -> State# d -> State# d
prefetchByteArray3# :: ByteArray# -> Int# -> State# d -> State# d
prefetchMutableByteArray3# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchAddr3# :: Addr# -> Int# -> State# d -> State# d
prefetchValue3# :: a -> State# d -> State# d
prefetchByteArray2# :: ByteArray# -> Int# -> State# d -> State# d
prefetchMutableByteArray2# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchAddr2# :: Addr# -> Int# -> State# d -> State# d
prefetchValue2# :: a -> State# d -> State# d
prefetchByteArray1# :: ByteArray# -> Int# -> State# d -> State# d
prefetchMutableByteArray1# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchAddr1# :: Addr# -> Int# -> State# d -> State# d
prefetchValue1# :: a -> State# d -> State# d
prefetchByteArray0# :: ByteArray# -> Int# -> State# d -> State# d
prefetchMutableByteArray0# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchAddr0# :: Addr# -> Int# -> State# d -> State# d
prefetchValue0# :: a -> State# d -> State# d
module GHC.Prim.Ext
shiftL# :: Word# -> Int# -> Word#
shiftRL# :: Word# -> Int# -> Word#
iShiftL# :: Int# -> Int# -> Int#
iShiftRA# :: Int# -> Int# -> Int#
iShiftRL# :: Int# -> Int# -> Int#
uncheckedShiftL64# :: Word# -> Int# -> Word#
uncheckedShiftRL64# :: Word# -> Int# -> Word#
uncheckedIShiftL64# :: Int# -> Int# -> Int#
uncheckedIShiftRA64# :: Int# -> Int# -> Int#
isTrue# :: Int# -> Bool
atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s, c #)
resizeSmallMutableArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> (# State# s, SmallMutableArray# s a #)
build :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
augment :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a] -> [a]
class IsString a where
- fromString :: String -> a
breakpoint :: a -> a
breakpointCond :: Bool -> a -> a
lazy :: a -> a
inline :: a -> a
oneShot :: forall (q :: RuntimeRep) (r :: RuntimeRep) (a :: TYPE q) (b :: TYPE r). (a -> b) -> a -> b
runRW# :: forall (r :: RuntimeRep) (o :: TYPE r). (State# RealWorld -> o) -> o
coerce :: forall (k :: RuntimeRep) (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
class a ~R# b => Coercible (a :: k) (b :: k)
class a ~# b => (a :: k0) ~~ (b :: k1)
data TYPE (a :: RuntimeRep)
data RuntimeRep
- = VecRep VecCount VecElem
- | TupleRep [RuntimeRep]
- | SumRep [RuntimeRep]
- | LiftedRep
- | UnliftedRep
- | IntRep
- | Int8Rep
- | Int16Rep
- | Int32Rep
- | Int64Rep
- | WordRep
- | Word8Rep
- | Word16Rep
- | Word32Rep
- | Word64Rep
- | AddrRep
- | FloatRep
- | DoubleRep
data VecCount
- = Vec2
- | Vec4
- | Vec8
- | Vec16
- | Vec32
- | Vec64
data VecElem
- = Int8ElemRep
- | Int16ElemRep
- | Int32ElemRep
- | Int64ElemRep
- | Word8ElemRep
- | Word16ElemRep
- | Word32ElemRep
- | Word64ElemRep
- | FloatElemRep
- | DoubleElemRep
newtype Down a = Down {
- getDown :: a
}
groupWith :: Ord b => (a -> b) -> [a] -> [[a]]
sortWith :: Ord b => (a -> b) -> [a] -> [a]
the :: Eq a => [a] -> a
traceEvent :: String -> IO ()
data SpecConstrAnnotation
- = NoSpecConstr
- | ForceSpecConstr
currentCallStack :: IO [String]
data Constraint
type family Any :: k where ...
class IsList l where
- type Item l
- fromList :: [Item l] -> l
- fromListN :: Int -> [Item l] -> l
- toList :: l -> [Item l]

Representations of some basic types

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

Instances details

Bounded Int #	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Int Source # maxBound :: Int Source #
Enum Int #	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Int -> Int Source # pred :: Int -> Int Source # toEnum :: Int -> Int Source # fromEnum :: Int -> Int Source # enumFrom :: Int -> [Int] Source # enumFromThen :: Int -> Int -> [Int] Source # enumFromTo :: Int -> Int -> [Int] Source # enumFromThenTo :: Int -> Int -> Int -> [Int] Source #
Eq Int
Instance details Defined in GHC.Classes Methods (==) :: Int -> Int -> Bool Source # (/=) :: Int -> Int -> Bool Source #
Integral Int #	Since: base-2.0.1
Instance details Defined in GHC.Real Methods quot :: Int -> Int -> Int Source # rem :: Int -> Int -> Int Source # div :: Int -> Int -> Int Source # mod :: Int -> Int -> Int Source # quotRem :: Int -> Int -> (Int, Int) Source # divMod :: Int -> Int -> (Int, Int) Source # toInteger :: Int -> Integer Source #
Data Int #	Since: base-4.0.0.0
Instance details 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 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int Source # toConstr :: Int -> Constr Source # dataTypeOf :: Int -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) Source # gmapT :: (forall b. Data b => b -> b) -> Int -> Int Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int Source #
Num Int #	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Int -> Int -> Int Source # (-) :: Int -> Int -> Int Source # (*) :: Int -> Int -> Int Source # negate :: Int -> Int Source # abs :: Int -> Int Source # signum :: Int -> Int Source # fromInteger :: Integer -> Int Source #
Ord Int
Instance details Defined in GHC.Classes Methods compare :: Int -> Int -> Ordering Source # (<) :: Int -> Int -> Bool Source # (<=) :: Int -> Int -> Bool Source # (>) :: Int -> Int -> Bool Source # (>=) :: Int -> Int -> Bool Source # max :: Int -> Int -> Int Source # min :: Int -> Int -> Int Source #
Read Int #	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Int Source # readList :: ReadS [Int] Source # readPrec :: ReadPrec Int Source # readListPrec :: ReadPrec [Int] Source #
Real Int #	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Int -> Rational Source #
Show Int #	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Int -> ShowS Source # show :: Int -> String Source # showList :: [Int] -> ShowS Source #
Ix Int #	Since: base-2.1
Instance details Defined in GHC.Ix Methods range :: (Int, Int) -> [Int] Source # index :: (Int, Int) -> Int -> Int Source # unsafeIndex :: (Int, Int) -> Int -> Int Source # inRange :: (Int, Int) -> Int -> Bool Source # rangeSize :: (Int, Int) -> Int Source # unsafeRangeSize :: (Int, Int) -> Int Source #
FiniteBits Int #	Since: base-4.6.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Int -> Int Source # countLeadingZeros :: Int -> Int Source # countTrailingZeros :: Int -> Int Source #
Bits Int #	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Int -> Int -> Int Source # (.\|.) :: Int -> Int -> Int Source # xor :: Int -> Int -> Int Source # complement :: Int -> Int Source # shift :: Int -> Int -> Int Source # rotate :: Int -> Int -> Int Source # zeroBits :: Int Source # bit :: Int -> Int Source # setBit :: Int -> Int -> Int Source # clearBit :: Int -> Int -> Int Source # complementBit :: Int -> Int -> Int Source # testBit :: Int -> Int -> Bool Source # bitSizeMaybe :: Int -> Maybe Int Source # bitSize :: Int -> Int Source # isSigned :: Int -> Bool Source # shiftL :: Int -> Int -> Int Source # unsafeShiftL :: Int -> Int -> Int Source # shiftR :: Int -> Int -> Int Source # unsafeShiftR :: Int -> Int -> Int Source # rotateL :: Int -> Int -> Int Source # rotateR :: Int -> Int -> Int Source # popCount :: Int -> Int Source #
Storable Int #	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int -> Int Source # alignment :: Int -> Int Source # peekElemOff :: Ptr Int -> Int -> IO Int Source # pokeElemOff :: Ptr Int -> Int -> Int -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Int Source # pokeByteOff :: Ptr b -> Int -> Int -> IO () Source # peek :: Ptr Int -> IO Int Source # poke :: Ptr Int -> Int -> IO () Source #
PrintfArg Int #	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Int -> FieldFormatter Source # parseFormat :: Int -> ModifierParser Source #
Generic1 (URec Int :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Int) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Int a -> Rep1 (URec Int) a Source # to1 :: forall (a :: k0). Rep1 (URec Int) a -> URec Int a Source #
Foldable (UInt :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m Source # foldMap :: Monoid m => (a -> m) -> UInt a -> m Source # foldMap' :: Monoid m => (a -> m) -> UInt a -> m Source # foldr :: (a -> b -> b) -> b -> UInt a -> b Source # foldr' :: (a -> b -> b) -> b -> UInt a -> b Source # foldl :: (b -> a -> b) -> b -> UInt a -> b Source # foldl' :: (b -> a -> b) -> b -> UInt a -> b Source # foldr1 :: (a -> a -> a) -> UInt a -> a Source # foldl1 :: (a -> a -> a) -> UInt a -> a Source # toList :: UInt a -> [a] Source # null :: UInt a -> Bool Source # length :: UInt a -> Int Source # elem :: Eq a => a -> UInt a -> Bool Source # maximum :: Ord a => UInt a -> a Source # minimum :: Ord a => UInt a -> a Source # sum :: Num a => UInt a -> a Source # product :: Num a => UInt a -> a Source #
Traversable (UInt :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UInt a -> f (UInt b) Source # sequenceA :: Applicative f => UInt (f a) -> f (UInt a) Source # mapM :: Monad m => (a -> m b) -> UInt a -> m (UInt b) Source # sequence :: Monad m => UInt (m a) -> m (UInt a) Source #
Functor (URec Int :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Int a -> URec Int b Source # (<$) :: a -> URec Int b -> URec Int a Source #
Eq (URec Int p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Int p -> URec Int p -> Bool Source # (/=) :: URec Int p -> URec Int p -> Bool Source #
Ord (URec Int p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Int p -> URec Int p -> Ordering Source # (<) :: URec Int p -> URec Int p -> Bool Source # (<=) :: URec Int p -> URec Int p -> Bool Source # (>) :: URec Int p -> URec Int p -> Bool Source # (>=) :: URec Int p -> URec Int p -> Bool Source # max :: URec Int p -> URec Int p -> URec Int p Source # min :: URec Int p -> URec Int p -> URec Int p Source #
Show (URec Int p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Int p -> ShowS Source # show :: URec Int p -> String Source # showList :: [URec Int p] -> ShowS Source #
Generic (URec Int p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type Source # Methods from :: URec Int p -> Rep (URec Int p) x Source # to :: Rep (URec Int p) x -> URec Int p Source #
data URec Int (p :: k) #	Used for marking occurrences of `Int#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Int (p :: k) = UInt { uInt# :: Int# }
type Rep1 (URec Int :: k -> Type) #
Instance details 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) #
Instance details 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 Source #

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

Constructors

W# Word#

Instances

Instances details

Bounded Word #	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Word Source # maxBound :: Word Source #
Enum Word #	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Word -> Word Source # pred :: Word -> Word Source # toEnum :: Int -> Word Source # fromEnum :: Word -> Int Source # enumFrom :: Word -> [Word] Source # enumFromThen :: Word -> Word -> [Word] Source # enumFromTo :: Word -> Word -> [Word] Source # enumFromThenTo :: Word -> Word -> Word -> [Word] Source #
Eq Word
Instance details Defined in GHC.Classes Methods (==) :: Word -> Word -> Bool Source # (/=) :: Word -> Word -> Bool Source #
Integral Word #	Since: base-2.1
Instance details Defined in GHC.Real Methods quot :: Word -> Word -> Word Source # rem :: Word -> Word -> Word Source # div :: Word -> Word -> Word Source # mod :: Word -> Word -> Word Source # quotRem :: Word -> Word -> (Word, Word) Source # divMod :: Word -> Word -> (Word, Word) Source # toInteger :: Word -> Integer Source #
Data Word #	Since: base-4.0.0.0
Instance details 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 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word Source # toConstr :: Word -> Constr Source # dataTypeOf :: Word -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) Source # gmapT :: (forall b. Data b => b -> b) -> Word -> Word Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word Source #
Num Word #	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Word -> Word -> Word Source # (-) :: Word -> Word -> Word Source # (*) :: Word -> Word -> Word Source # negate :: Word -> Word Source # abs :: Word -> Word Source # signum :: Word -> Word Source # fromInteger :: Integer -> Word Source #
Ord Word
Instance details Defined in GHC.Classes Methods compare :: Word -> Word -> Ordering Source # (<) :: Word -> Word -> Bool Source # (<=) :: Word -> Word -> Bool Source # (>) :: Word -> Word -> Bool Source # (>=) :: Word -> Word -> Bool Source # max :: Word -> Word -> Word Source # min :: Word -> Word -> Word Source #
Read Word #	Since: base-4.5.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word Source # readList :: ReadS [Word] Source # readPrec :: ReadPrec Word Source # readListPrec :: ReadPrec [Word] Source #
Real Word #	Since: base-2.1
Instance details Defined in GHC.Real Methods toRational :: Word -> Rational Source #
Show Word #	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Word -> ShowS Source # show :: Word -> String Source # showList :: [Word] -> ShowS Source #
Ix Word #	Since: base-4.6.0.0
Instance details Defined in GHC.Ix Methods range :: (Word, Word) -> [Word] Source # index :: (Word, Word) -> Word -> Int Source # unsafeIndex :: (Word, Word) -> Word -> Int Source # inRange :: (Word, Word) -> Word -> Bool Source # rangeSize :: (Word, Word) -> Int Source # unsafeRangeSize :: (Word, Word) -> Int Source #
FiniteBits Word #	Since: base-4.6.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Word -> Int Source # countLeadingZeros :: Word -> Int Source # countTrailingZeros :: Word -> Int Source #
Bits Word #	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Word -> Word -> Word Source # (.\|.) :: Word -> Word -> Word Source # xor :: Word -> Word -> Word Source # complement :: Word -> Word Source # shift :: Word -> Int -> Word Source # rotate :: Word -> Int -> Word Source # zeroBits :: Word Source # bit :: Int -> Word Source # setBit :: Word -> Int -> Word Source # clearBit :: Word -> Int -> Word Source # complementBit :: Word -> Int -> Word Source # testBit :: Word -> Int -> Bool Source # bitSizeMaybe :: Word -> Maybe Int Source # bitSize :: Word -> Int Source # isSigned :: Word -> Bool Source # shiftL :: Word -> Int -> Word Source # unsafeShiftL :: Word -> Int -> Word Source # shiftR :: Word -> Int -> Word Source # unsafeShiftR :: Word -> Int -> Word Source # rotateL :: Word -> Int -> Word Source # rotateR :: Word -> Int -> Word Source # popCount :: Word -> Int Source #
Storable Word #	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word -> Int Source # alignment :: Word -> Int Source # peekElemOff :: Ptr Word -> Int -> IO Word Source # pokeElemOff :: Ptr Word -> Int -> Word -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Word Source # pokeByteOff :: Ptr b -> Int -> Word -> IO () Source # peek :: Ptr Word -> IO Word Source # poke :: Ptr Word -> Word -> IO () Source #
PrintfArg Word #	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Word -> FieldFormatter Source # parseFormat :: Word -> ModifierParser Source #
Generic1 (URec Word :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Word) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Word a -> Rep1 (URec Word) a Source # to1 :: forall (a :: k0). Rep1 (URec Word) a -> URec Word a Source #
Foldable (UWord :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m Source # foldMap :: Monoid m => (a -> m) -> UWord a -> m Source # foldMap' :: Monoid m => (a -> m) -> UWord a -> m Source # foldr :: (a -> b -> b) -> b -> UWord a -> b Source # foldr' :: (a -> b -> b) -> b -> UWord a -> b Source # foldl :: (b -> a -> b) -> b -> UWord a -> b Source # foldl' :: (b -> a -> b) -> b -> UWord a -> b Source # foldr1 :: (a -> a -> a) -> UWord a -> a Source # foldl1 :: (a -> a -> a) -> UWord a -> a Source # toList :: UWord a -> [a] Source # null :: UWord a -> Bool Source # length :: UWord a -> Int Source # elem :: Eq a => a -> UWord a -> Bool Source # maximum :: Ord a => UWord a -> a Source # minimum :: Ord a => UWord a -> a Source # sum :: Num a => UWord a -> a Source # product :: Num a => UWord a -> a Source #
Traversable (UWord :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b) Source # sequenceA :: Applicative f => UWord (f a) -> f (UWord a) Source # mapM :: Monad m => (a -> m b) -> UWord a -> m (UWord b) Source # sequence :: Monad m => UWord (m a) -> m (UWord a) Source #
Functor (URec Word :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Word a -> URec Word b Source # (<$) :: a -> URec Word b -> URec Word a Source #
Eq (URec Word p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Word p -> URec Word p -> Bool Source # (/=) :: URec Word p -> URec Word p -> Bool Source #
Ord (URec Word p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Word p -> URec Word p -> Ordering Source # (<) :: URec Word p -> URec Word p -> Bool Source # (<=) :: URec Word p -> URec Word p -> Bool Source # (>) :: URec Word p -> URec Word p -> Bool Source # (>=) :: URec Word p -> URec Word p -> Bool Source # max :: URec Word p -> URec Word p -> URec Word p Source # min :: URec Word p -> URec Word p -> URec Word p Source #
Show (URec Word p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Word p -> ShowS Source # show :: URec Word p -> String Source # showList :: [URec Word p] -> ShowS Source #
Generic (URec Word p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type Source # Methods from :: URec Word p -> Rep (URec Word p) x Source # to :: Rep (URec Word p) x -> URec Word p Source #
data URec Word (p :: k) #	Used for marking occurrences of `Word#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Word (p :: k) = UWord { uWord# :: Word# }
type Rep1 (URec Word :: k -> Type) #
Instance details 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) #
Instance details 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 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

Instances details

Enum Float #	Since: base-2.1
Instance details Defined in GHC.Float Methods succ :: Float -> Float Source # pred :: Float -> Float Source # toEnum :: Int -> Float Source # fromEnum :: Float -> Int Source # enumFrom :: Float -> [Float] Source # enumFromThen :: Float -> Float -> [Float] Source # enumFromTo :: Float -> Float -> [Float] Source # enumFromThenTo :: Float -> Float -> Float -> [Float] Source #
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 substitutivity: `>>>` `0 == (-0 :: Float)`True `>>>` `recip 0 == recip (-0 :: Float)`False
Instance details Defined in GHC.Classes Methods (==) :: Float -> Float -> Bool Source # (/=) :: Float -> Float -> Bool Source #
Floating Float #	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Float Source # exp :: Float -> Float Source # log :: Float -> Float Source # sqrt :: Float -> Float Source # (**) :: Float -> Float -> Float Source # logBase :: Float -> Float -> Float Source # sin :: Float -> Float Source # cos :: Float -> Float Source # tan :: Float -> Float Source # asin :: Float -> Float Source # acos :: Float -> Float Source # atan :: Float -> Float Source # sinh :: Float -> Float Source # cosh :: Float -> Float Source # tanh :: Float -> Float Source # asinh :: Float -> Float Source # acosh :: Float -> Float Source # atanh :: Float -> Float Source # log1p :: Float -> Float Source # expm1 :: Float -> Float Source # log1pexp :: Float -> Float Source # log1mexp :: Float -> Float Source #
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*
Instance details Defined in GHC.Float Methods (/) :: Float -> Float -> Float Source # recip :: Float -> Float Source # fromRational :: Rational -> Float Source #
Data Float #	Since: base-4.0.0.0
Instance details 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 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float Source # toConstr :: Float -> Constr Source # dataTypeOf :: Float -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) Source # gmapT :: (forall b. Data b => b -> b) -> Float -> Float Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float Source #
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
Instance details Defined in GHC.Float Methods (+) :: Float -> Float -> Float Source # (-) :: Float -> Float -> Float Source # (*) :: Float -> Float -> Float Source # negate :: Float -> Float Source # abs :: Float -> Float Source # signum :: Float -> Float Source # fromInteger :: Integer -> Float Source #
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
Instance details Defined in GHC.Classes Methods compare :: Float -> Float -> Ordering Source # (<) :: Float -> Float -> Bool Source # (<=) :: Float -> Float -> Bool Source # (>) :: Float -> Float -> Bool Source # (>=) :: Float -> Float -> Bool Source # max :: Float -> Float -> Float Source # min :: Float -> Float -> Float Source #
Read Float #	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Float Source # readList :: ReadS [Float] Source # readPrec :: ReadPrec Float Source # readListPrec :: ReadPrec [Float] Source #
Real Float #	Since: base-2.1
Instance details Defined in GHC.Float Methods toRational :: Float -> Rational Source #
RealFloat Float #	Since: base-2.1
Instance details Defined in GHC.Float Methods floatRadix :: Float -> Integer Source # floatDigits :: Float -> Int Source # floatRange :: Float -> (Int, Int) Source # decodeFloat :: Float -> (Integer, Int) Source # encodeFloat :: Integer -> Int -> Float Source # exponent :: Float -> Int Source # significand :: Float -> Float Source # scaleFloat :: Int -> Float -> Float Source # isNaN :: Float -> Bool Source # isInfinite :: Float -> Bool Source # isDenormalized :: Float -> Bool Source # isNegativeZero :: Float -> Bool Source # isIEEE :: Float -> Bool Source # atan2 :: Float -> Float -> Float Source #
RealFrac Float #	Since: base-2.1
Instance details Defined in GHC.Float Methods properFraction :: Integral b => Float -> (b, Float) Source # truncate :: Integral b => Float -> b Source # round :: Integral b => Float -> b Source # ceiling :: Integral b => Float -> b Source # floor :: Integral b => Float -> b Source #
Show Float #	Since: base-2.1
Instance details Defined in GHC.Float Methods showsPrec :: Int -> Float -> ShowS Source # show :: Float -> String Source # showList :: [Float] -> ShowS Source #
Storable Float #	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Float -> Int Source # alignment :: Float -> Int Source # peekElemOff :: Ptr Float -> Int -> IO Float Source # pokeElemOff :: Ptr Float -> Int -> Float -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Float Source # pokeByteOff :: Ptr b -> Int -> Float -> IO () Source # peek :: Ptr Float -> IO Float Source # poke :: Ptr Float -> Float -> IO () Source #
PrintfArg Float #	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Float -> FieldFormatter Source # parseFormat :: Float -> ModifierParser Source #
Generic1 (URec Float :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Float) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Float a -> Rep1 (URec Float) a Source # to1 :: forall (a :: k0). Rep1 (URec Float) a -> URec Float a Source #
Foldable (UFloat :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m Source # foldMap :: Monoid m => (a -> m) -> UFloat a -> m Source # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m Source # foldr :: (a -> b -> b) -> b -> UFloat a -> b Source # foldr' :: (a -> b -> b) -> b -> UFloat a -> b Source # foldl :: (b -> a -> b) -> b -> UFloat a -> b Source # foldl' :: (b -> a -> b) -> b -> UFloat a -> b Source # foldr1 :: (a -> a -> a) -> UFloat a -> a Source # foldl1 :: (a -> a -> a) -> UFloat a -> a Source # toList :: UFloat a -> [a] Source # null :: UFloat a -> Bool Source # length :: UFloat a -> Int Source # elem :: Eq a => a -> UFloat a -> Bool Source # maximum :: Ord a => UFloat a -> a Source # minimum :: Ord a => UFloat a -> a Source # sum :: Num a => UFloat a -> a Source # product :: Num a => UFloat a -> a Source #
Traversable (UFloat :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b) Source # sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a) Source # mapM :: Monad m => (a -> m b) -> UFloat a -> m (UFloat b) Source # sequence :: Monad m => UFloat (m a) -> m (UFloat a) Source #
Functor (URec Float :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Float a -> URec Float b Source # (<$) :: a -> URec Float b -> URec Float a Source #
Eq (URec Float p) #
Instance details Defined in GHC.Generics Methods (==) :: URec Float p -> URec Float p -> Bool Source # (/=) :: URec Float p -> URec Float p -> Bool Source #
Ord (URec Float p) #
Instance details Defined in GHC.Generics Methods compare :: URec Float p -> URec Float p -> Ordering Source # (<) :: URec Float p -> URec Float p -> Bool Source # (<=) :: URec Float p -> URec Float p -> Bool Source # (>) :: URec Float p -> URec Float p -> Bool Source # (>=) :: URec Float p -> URec Float p -> Bool Source # max :: URec Float p -> URec Float p -> URec Float p Source # min :: URec Float p -> URec Float p -> URec Float p Source #
Show (URec Float p) #
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Float p -> ShowS Source # show :: URec Float p -> String Source # showList :: [URec Float p] -> ShowS Source #
Generic (URec Float p) #
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type Source # Methods from :: URec Float p -> Rep (URec Float p) x Source # to :: Rep (URec Float p) x -> URec Float p Source #
data URec Float (p :: k) #	Used for marking occurrences of `Float#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Float (p :: k) = UFloat { uFloat# :: Float# }
type Rep1 (URec Float :: k -> Type) #
Instance details 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) #
Instance details 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 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

Instances details

Enum Double #	Since: base-2.1
Instance details Defined in GHC.Float Methods succ :: Double -> Double Source # pred :: Double -> Double Source # toEnum :: Int -> Double Source # fromEnum :: Double -> Int Source # enumFrom :: Double -> [Double] Source # enumFromThen :: Double -> Double -> [Double] Source # enumFromTo :: Double -> Double -> [Double] Source # enumFromThenTo :: Double -> Double -> Double -> [Double] Source #
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
Instance details Defined in GHC.Classes Methods (==) :: Double -> Double -> Bool Source # (/=) :: Double -> Double -> Bool Source #
Floating Double #	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Double Source # exp :: Double -> Double Source # log :: Double -> Double Source # sqrt :: Double -> Double Source # (**) :: Double -> Double -> Double Source # logBase :: Double -> Double -> Double Source # sin :: Double -> Double Source # cos :: Double -> Double Source # tan :: Double -> Double Source # asin :: Double -> Double Source # acos :: Double -> Double Source # atan :: Double -> Double Source # sinh :: Double -> Double Source # cosh :: Double -> Double Source # tanh :: Double -> Double Source # asinh :: Double -> Double Source # acosh :: Double -> Double Source # atanh :: Double -> Double Source # log1p :: Double -> Double Source # expm1 :: Double -> Double Source # log1pexp :: Double -> Double Source # log1mexp :: Double -> Double Source #
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*
Instance details Defined in GHC.Float Methods (/) :: Double -> Double -> Double Source # recip :: Double -> Double Source # fromRational :: Rational -> Double Source #
Data Double #	Since: base-4.0.0.0
Instance details 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 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double Source # toConstr :: Double -> Constr Source # dataTypeOf :: Double -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) Source # gmapT :: (forall b. Data b => b -> b) -> Double -> Double Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double Source #
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
Instance details Defined in GHC.Float Methods (+) :: Double -> Double -> Double Source # (-) :: Double -> Double -> Double Source # (*) :: Double -> Double -> Double Source # negate :: Double -> Double Source # abs :: Double -> Double Source # signum :: Double -> Double Source # fromInteger :: Integer -> Double Source #
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
Instance details Defined in GHC.Classes Methods compare :: Double -> Double -> Ordering Source # (<) :: Double -> Double -> Bool Source # (<=) :: Double -> Double -> Bool Source # (>) :: Double -> Double -> Bool Source # (>=) :: Double -> Double -> Bool Source # max :: Double -> Double -> Double Source # min :: Double -> Double -> Double Source #
Read Double #	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Double Source # readList :: ReadS [Double] Source # readPrec :: ReadPrec Double Source # readListPrec :: ReadPrec [Double] Source #
Real Double #	Since: base-2.1
Instance details Defined in GHC.Float Methods toRational :: Double -> Rational Source #
RealFloat Double #	Since: base-2.1
Instance details Defined in GHC.Float Methods floatRadix :: Double -> Integer Source # floatDigits :: Double -> Int Source # floatRange :: Double -> (Int, Int) Source # decodeFloat :: Double -> (Integer, Int) Source # encodeFloat :: Integer -> Int -> Double Source # exponent :: Double -> Int Source # significand :: Double -> Double Source # scaleFloat :: Int -> Double -> Double Source # isNaN :: Double -> Bool Source # isInfinite :: Double -> Bool Source # isDenormalized :: Double -> Bool Source # isNegativeZero :: Double -> Bool Source # isIEEE :: Double -> Bool Source # atan2 :: Double -> Double -> Double Source #
RealFrac Double #	Since: base-2.1
Instance details Defined in GHC.Float Methods properFraction :: Integral b => Double -> (b, Double) Source # truncate :: Integral b => Double -> b Source # round :: Integral b => Double -> b Source # ceiling :: Integral b => Double -> b Source # floor :: Integral b => Double -> b Source #
Show Double #	Since: base-2.1
Instance details Defined in GHC.Float Methods showsPrec :: Int -> Double -> ShowS Source # show :: Double -> String Source # showList :: [Double] -> ShowS Source #
Storable Double #	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Double -> Int Source # alignment :: Double -> Int Source # peekElemOff :: Ptr Double -> Int -> IO Double Source # pokeElemOff :: Ptr Double -> Int -> Double -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Double Source # pokeByteOff :: Ptr b -> Int -> Double -> IO () Source # peek :: Ptr Double -> IO Double Source # poke :: Ptr Double -> Double -> IO () Source #
PrintfArg Double #	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Double -> FieldFormatter Source # parseFormat :: Double -> ModifierParser Source #
Generic1 (URec Double :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Double) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Double a -> Rep1 (URec Double) a Source # to1 :: forall (a :: k0). Rep1 (URec Double) a -> URec Double a Source #
Foldable (UDouble :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m Source # foldMap :: Monoid m => (a -> m) -> UDouble a -> m Source # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m Source # foldr :: (a -> b -> b) -> b -> UDouble a -> b Source # foldr' :: (a -> b -> b) -> b -> UDouble a -> b Source # foldl :: (b -> a -> b) -> b -> UDouble a -> b Source # foldl' :: (b -> a -> b) -> b -> UDouble a -> b Source # foldr1 :: (a -> a -> a) -> UDouble a -> a Source # foldl1 :: (a -> a -> a) -> UDouble a -> a Source # toList :: UDouble a -> [a] Source # null :: UDouble a -> Bool Source # length :: UDouble a -> Int Source # elem :: Eq a => a -> UDouble a -> Bool Source # maximum :: Ord a => UDouble a -> a Source # minimum :: Ord a => UDouble a -> a Source # sum :: Num a => UDouble a -> a Source # product :: Num a => UDouble a -> a Source #
Traversable (UDouble :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UDouble a -> f (UDouble b) Source # sequenceA :: Applicative f => UDouble (f a) -> f (UDouble a) Source # mapM :: Monad m => (a -> m b) -> UDouble a -> m (UDouble b) Source # sequence :: Monad m => UDouble (m a) -> m (UDouble a) Source #
Functor (URec Double :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Double a -> URec Double b Source # (<$) :: a -> URec Double b -> URec Double a Source #
Eq (URec Double p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Double p -> URec Double p -> Bool Source # (/=) :: URec Double p -> URec Double p -> Bool Source #
Ord (URec Double p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Double p -> URec Double p -> Ordering Source # (<) :: URec Double p -> URec Double p -> Bool Source # (<=) :: URec Double p -> URec Double p -> Bool Source # (>) :: URec Double p -> URec Double p -> Bool Source # (>=) :: URec Double p -> URec Double p -> Bool Source # max :: URec Double p -> URec Double p -> URec Double p Source # min :: URec Double p -> URec Double p -> URec Double p Source #
Show (URec Double p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Double p -> ShowS Source # show :: URec Double p -> String Source # showList :: [URec Double p] -> ShowS Source #
Generic (URec Double p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type Source # Methods from :: URec Double p -> Rep (URec Double p) x Source # to :: Rep (URec Double p) x -> URec Double p Source #
data URec Double (p :: k) #	Used for marking occurrences of `Double#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Double (p :: k) = UDouble { uDouble# :: Double# }
type Rep1 (URec Double :: k -> Type) #
Instance details 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) #
Instance details 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 Source #

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

Instances details

Bounded Char #	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Char Source # maxBound :: Char Source #
Enum Char #	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Char -> Char Source # pred :: Char -> Char Source # toEnum :: Int -> Char Source # fromEnum :: Char -> Int Source # enumFrom :: Char -> [Char] Source # enumFromThen :: Char -> Char -> [Char] Source # enumFromTo :: Char -> Char -> [Char] Source # enumFromThenTo :: Char -> Char -> Char -> [Char] Source #
Eq Char
Instance details Defined in GHC.Classes Methods (==) :: Char -> Char -> Bool Source # (/=) :: Char -> Char -> Bool Source #
Data Char #	Since: base-4.0.0.0
Instance details 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 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char Source # toConstr :: Char -> Constr Source # dataTypeOf :: Char -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) Source # gmapT :: (forall b. Data b => b -> b) -> Char -> Char Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char Source #
Ord Char
Instance details Defined in GHC.Classes Methods compare :: Char -> Char -> Ordering Source # (<) :: Char -> Char -> Bool Source # (<=) :: Char -> Char -> Bool Source # (>) :: Char -> Char -> Bool Source # (>=) :: Char -> Char -> Bool Source # max :: Char -> Char -> Char Source # min :: Char -> Char -> Char Source #
Read Char #	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Char Source # readList :: ReadS [Char] Source # readPrec :: ReadPrec Char Source # readListPrec :: ReadPrec [Char] Source #
Show Char #	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Char -> ShowS Source # show :: Char -> String Source # showList :: [Char] -> ShowS Source #
Ix Char #	Since: base-2.1
Instance details Defined in GHC.Ix Methods range :: (Char, Char) -> [Char] Source # index :: (Char, Char) -> Char -> Int Source # unsafeIndex :: (Char, Char) -> Char -> Int Source # inRange :: (Char, Char) -> Char -> Bool Source # rangeSize :: (Char, Char) -> Int Source # unsafeRangeSize :: (Char, Char) -> Int Source #
Storable Char #	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Char -> Int Source # alignment :: Char -> Int Source # peekElemOff :: Ptr Char -> Int -> IO Char Source # pokeElemOff :: Ptr Char -> Int -> Char -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Char Source # pokeByteOff :: Ptr b -> Int -> Char -> IO () Source # peek :: Ptr Char -> IO Char Source # poke :: Ptr Char -> Char -> IO () Source #
IsChar Char #	Since: base-2.1
Instance details Defined in Text.Printf Methods toChar :: Char -> Char Source # fromChar :: Char -> Char Source #
PrintfArg Char #	Since: base-2.1
Instance details Defined in Text.Printf Methods formatArg :: Char -> FieldFormatter Source # parseFormat :: Char -> ModifierParser Source #
Generic1 (URec Char :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Char) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Char a -> Rep1 (URec Char) a Source # to1 :: forall (a :: k0). Rep1 (URec Char) a -> URec Char a Source #
Foldable (UChar :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m Source # foldMap :: Monoid m => (a -> m) -> UChar a -> m Source # foldMap' :: Monoid m => (a -> m) -> UChar a -> m Source # foldr :: (a -> b -> b) -> b -> UChar a -> b Source # foldr' :: (a -> b -> b) -> b -> UChar a -> b Source # foldl :: (b -> a -> b) -> b -> UChar a -> b Source # foldl' :: (b -> a -> b) -> b -> UChar a -> b Source # foldr1 :: (a -> a -> a) -> UChar a -> a Source # foldl1 :: (a -> a -> a) -> UChar a -> a Source # toList :: UChar a -> [a] Source # null :: UChar a -> Bool Source # length :: UChar a -> Int Source # elem :: Eq a => a -> UChar a -> Bool Source # maximum :: Ord a => UChar a -> a Source # minimum :: Ord a => UChar a -> a Source # sum :: Num a => UChar a -> a Source # product :: Num a => UChar a -> a Source #
Traversable (UChar :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UChar a -> f (UChar b) Source # sequenceA :: Applicative f => UChar (f a) -> f (UChar a) Source # mapM :: Monad m => (a -> m b) -> UChar a -> m (UChar b) Source # sequence :: Monad m => UChar (m a) -> m (UChar a) Source #
Functor (URec Char :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Char a -> URec Char b Source # (<$) :: a -> URec Char b -> URec Char a Source #
Eq (URec Char p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Char p -> URec Char p -> Bool Source # (/=) :: URec Char p -> URec Char p -> Bool Source #
Ord (URec Char p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Char p -> URec Char p -> Ordering Source # (<) :: URec Char p -> URec Char p -> Bool Source # (<=) :: URec Char p -> URec Char p -> Bool Source # (>) :: URec Char p -> URec Char p -> Bool Source # (>=) :: URec Char p -> URec Char p -> Bool Source # max :: URec Char p -> URec Char p -> URec Char p Source # min :: URec Char p -> URec Char p -> URec Char p Source #
Show (URec Char p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Char p -> ShowS Source # show :: URec Char p -> String Source # showList :: [URec Char p] -> ShowS Source #
Generic (URec Char p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type Source # Methods from :: URec Char p -> Rep (URec Char p) x Source # to :: Rep (URec Char p) x -> URec Char p Source #
data URec Char (p :: k) #	Used for marking occurrences of `Char#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Char (p :: k) = UChar { uChar# :: Char# }
type Rep1 (URec Char :: k -> Type) #
Instance details 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) #
Instance details 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 Source #

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

Instances details

Generic1 (URec (Ptr ()) :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec (Ptr ())) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a Source # to1 :: forall (a :: k0). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a Source #
Eq (Ptr a) #	Since: base-2.1
Instance details Defined in GHC.Ptr Methods (==) :: Ptr a -> Ptr a -> Bool Source # (/=) :: Ptr a -> Ptr a -> Bool Source #
Data a => Data (Ptr a) #	Since: base-4.8.0.0
Instance details 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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ptr a) Source # toConstr :: Ptr a -> Constr Source # dataTypeOf :: Ptr a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ptr a)) Source # gmapT :: (forall b. Data b => b -> b) -> Ptr a -> Ptr a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source #
Ord (Ptr a) #	Since: base-2.1
Instance details Defined in GHC.Ptr Methods compare :: Ptr a -> Ptr a -> Ordering Source # (<) :: Ptr a -> Ptr a -> Bool Source # (<=) :: Ptr a -> Ptr a -> Bool Source # (>) :: Ptr a -> Ptr a -> Bool Source # (>=) :: Ptr a -> Ptr a -> Bool Source # max :: Ptr a -> Ptr a -> Ptr a Source # min :: Ptr a -> Ptr a -> Ptr a Source #
Show (Ptr a) #	Since: base-2.1
Instance details Defined in GHC.Ptr Methods showsPrec :: Int -> Ptr a -> ShowS Source # show :: Ptr a -> String Source # showList :: [Ptr a] -> ShowS Source #
Foldable (UAddr :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UAddr m -> m Source # foldMap :: Monoid m => (a -> m) -> UAddr a -> m Source # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m Source # foldr :: (a -> b -> b) -> b -> UAddr a -> b Source # foldr' :: (a -> b -> b) -> b -> UAddr a -> b Source # foldl :: (b -> a -> b) -> b -> UAddr a -> b Source # foldl' :: (b -> a -> b) -> b -> UAddr a -> b Source # foldr1 :: (a -> a -> a) -> UAddr a -> a Source # foldl1 :: (a -> a -> a) -> UAddr a -> a Source # toList :: UAddr a -> [a] Source # null :: UAddr a -> Bool Source # length :: UAddr a -> Int Source # elem :: Eq a => a -> UAddr a -> Bool Source # maximum :: Ord a => UAddr a -> a Source # minimum :: Ord a => UAddr a -> a Source # sum :: Num a => UAddr a -> a Source # product :: Num a => UAddr a -> a Source #
Traversable (UAddr :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UAddr a -> f (UAddr b) Source # sequenceA :: Applicative f => UAddr (f a) -> f (UAddr a) Source # mapM :: Monad m => (a -> m b) -> UAddr a -> m (UAddr b) Source # sequence :: Monad m => UAddr (m a) -> m (UAddr a) Source #
Storable (Ptr a) #	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Ptr a -> Int Source # alignment :: Ptr a -> Int Source # peekElemOff :: Ptr (Ptr a) -> Int -> IO (Ptr a) Source # pokeElemOff :: Ptr (Ptr a) -> Int -> Ptr a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO (Ptr a) Source # pokeByteOff :: Ptr b -> Int -> Ptr a -> IO () Source # peek :: Ptr (Ptr a) -> IO (Ptr a) Source # poke :: Ptr (Ptr a) -> Ptr a -> IO () Source #
Functor (URec (Ptr ()) :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b Source # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a Source #
Eq (URec (Ptr ()) p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source #
Ord (URec (Ptr ()) p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering Source # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source #
Generic (URec (Ptr ()) p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type Rep (URec (Ptr ()) p) :: Type -> Type Source # Methods from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x Source # to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p Source #
data URec (Ptr ()) (p :: k) #	Used for marking occurrences of `Addr#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec (Ptr ()) (p :: k) = UAddr { uAddr# :: Addr# }
type Rep1 (URec (Ptr ()) :: k -> Type) #
Instance details 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) #
Instance details 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 Source #

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

Instances details

Eq (FunPtr a) #
Instance details Defined in GHC.Ptr Methods (==) :: FunPtr a -> FunPtr a -> Bool Source # (/=) :: FunPtr a -> FunPtr a -> Bool Source #
Ord (FunPtr a) #
Instance details Defined in GHC.Ptr Methods compare :: FunPtr a -> FunPtr a -> Ordering Source # (<) :: FunPtr a -> FunPtr a -> Bool Source # (<=) :: FunPtr a -> FunPtr a -> Bool Source # (>) :: FunPtr a -> FunPtr a -> Bool Source # (>=) :: FunPtr a -> FunPtr a -> Bool Source # max :: FunPtr a -> FunPtr a -> FunPtr a Source # min :: FunPtr a -> FunPtr a -> FunPtr a Source #
Show (FunPtr a) #	Since: base-2.1
Instance details Defined in GHC.Ptr Methods showsPrec :: Int -> FunPtr a -> ShowS Source # show :: FunPtr a -> String Source # showList :: [FunPtr a] -> ShowS Source #
Storable (FunPtr a) #	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: FunPtr a -> Int Source # alignment :: FunPtr a -> Int Source # peekElemOff :: Ptr (FunPtr a) -> Int -> IO (FunPtr a) Source # pokeElemOff :: Ptr (FunPtr a) -> Int -> FunPtr a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO (FunPtr a) Source # pokeByteOff :: Ptr b -> Int -> FunPtr a -> IO () Source # peek :: Ptr (FunPtr a) -> IO (FunPtr a) Source # poke :: Ptr (FunPtr a) -> FunPtr a -> IO () Source #

The maximum tuple size

maxTupleSize :: Int Source #

Primitive operations

seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b infixr 0 Source #

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

void# :: Void# Source #

unsafeCoerce# :: forall (k0 :: RuntimeRep) (k1 :: RuntimeRep) (a :: TYPE k0) (b :: TYPE k1). a -> b Source #

The function unsafeCoerce# allows you to side-step the typechecker entirely. That is, it allows you to coerce any type into any other type. If you use this function, you had better get it right, otherwise segmentation faults await. It is generally used when you want to write a program that you know is well-typed, but where Haskell's type system is not expressive enough to prove that it is well typed.

The following uses of unsafeCoerce# are supposed to work (i.e. not lead to spurious compile-time or run-time crashes):

Casting any lifted type to Any
Casting Any back to the real type
Casting an unboxed type to another unboxed type of the same size. (Casting between floating-point and integral types does not work. See the GHC.Float module for functions to do work.)
Casting between two types that have the same runtime representation. One case is when the two types differ only in "phantom" type parameters, for example Ptr Int to Ptr Float, or [Int] to [Float] when the list is known to be empty. Also, a newtype of a type T has the same representation at runtime as T.

Other uses of unsafeCoerce# are undefined. In particular, you should not use unsafeCoerce# to cast a T to an algebraic data type D, unless T is also an algebraic data type. For example, do not cast Int->Int to Bool, even if you later cast that Bool back to Int->Int before applying it. The reasons have to do with GHC's internal representation details (for the cognoscenti, data values can be entered but function closures cannot). If you want a safe type to cast things to, use Any, which is not an algebraic data type.

Warning: this can fail with an unchecked exception.

nullAddr# :: Addr# Source #

The null address.

magicDict :: a Source #

proxy# :: forall k (a :: k). Proxy# a Source #

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

data Addr# :: TYPE 'AddrRep Source #

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

data Array# a :: TYPE 'UnliftedRep Source #

data ByteArray# :: TYPE 'UnliftedRep Source #

data Char# :: TYPE 'WordRep Source #

data Double# :: TYPE 'DoubleRep Source #

data Float# :: TYPE 'FloatRep Source #

data Int# :: TYPE 'IntRep Source #

data Int8# :: TYPE 'Int8Rep Source #

data Int16# :: TYPE 'Int16Rep Source #

data Int32# :: TYPE 'Int32Rep Source #

data Int64# :: TYPE 'Int64Rep Source #

data Weak# a :: TYPE 'UnliftedRep Source #

data MutableArray# a b :: TYPE 'UnliftedRep Source #

data MutableByteArray# a :: TYPE 'UnliftedRep Source #

data MVar# a b :: TYPE 'UnliftedRep Source #

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 RealWorld Source #

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

data ArrayArray# :: TYPE 'UnliftedRep Source #

data MutableArrayArray# a :: TYPE 'UnliftedRep Source #

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

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 :: TYPE 'UnliftedRep Source #

data MutVar# a b :: TYPE 'UnliftedRep Source #

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

data Void# :: TYPE ('TupleRep ('[] :: [RuntimeRep])) Source #

data Word# :: TYPE 'WordRep Source #

data Word8# :: TYPE 'Word8Rep Source #

data Word16# :: TYPE 'Word16Rep Source #

data Word32# :: TYPE 'Word32Rep Source #

data Word64# :: TYPE 'Word64Rep Source #

data ThreadId# :: TYPE 'UnliftedRep Source #

(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# :: TYPE 'UnliftedRep Source #

Primitive bytecode type.

data TVar# a b :: TYPE 'UnliftedRep Source #

data Compact# :: TYPE 'UnliftedRep Source #

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

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 :: TYPE 'UnliftedRep Source #

data SmallMutableArray# a b :: TYPE 'UnliftedRep Source #

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