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

GHC.Internal.Base

Description

Basic data types and classes.

Synopsis

type String = [Char]
class Applicative m => Monad (m :: Type -> Type) where
- (>>=) :: m a -> (a -> m b) -> m b
- (>>) :: m a -> m b -> m b
- return :: a -> m a
(.) :: (b -> c) -> (a -> b) -> a -> c
id :: a -> a
assert :: Bool -> a -> a
class Functor (f :: Type -> Type) where
- fmap :: (a -> b) -> f a -> f b
- (<$) :: a -> f b -> f a
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- mzero :: m a
- mplus :: m a -> m a -> m a
mapM :: Monad m => (a -> m b) -> [a] -> m [b]
sequence :: Monad m => [m a] -> m [a]
(=<<) :: Monad m => (a -> m b) -> m a -> m b
join :: Monad m => m (m a) -> m a
when :: Applicative f => Bool -> f () -> f ()
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
ap :: Monad m => m (a -> b) -> m a -> m b
failIO :: String -> IO a
class Semigroup a => Monoid a where
- mempty :: a
- mappend :: a -> a -> a
- mconcat :: [a] -> a
data NonEmpty a = a :| [a]
($) :: (a -> b) -> a -> b
otherwise :: Bool
foldr :: (a -> b -> b) -> b -> [a] -> b
const :: a -> b -> a
flip :: (a -> b -> c) -> b -> a -> c
class Functor f => Applicative (f :: Type -> Type) where
- pure :: a -> f a
- (<*>) :: f (a -> b) -> f a -> f b
- liftA2 :: (a -> b -> c) -> f a -> f b -> f c
- (*>) :: f a -> f b -> f b
- (<*) :: f a -> f b -> f a
class Semigroup a where
- (<>) :: a -> a -> a
- sconcat :: NonEmpty a -> a
- stimes :: Integral b => b -> a -> a
(++) :: [a] -> [a] -> [a]
map :: (a -> b) -> [a] -> [b]
data Void
absurd :: Void -> a
vacuous :: Functor f => f Void -> f a
class Applicative f => Alternative (f :: Type -> Type) where
- empty :: f a
- (<|>) :: f a -> f a -> f a
- some :: f a -> f [a]
- many :: f a -> f [a]
($!) :: (a -> b) -> a -> b
shiftL# :: Word# -> Int# -> Word#
shiftRL# :: Word# -> Int# -> Word#
iShiftL# :: Int# -> Int# -> Int#
iShiftRA# :: Int# -> Int# -> Int#
iShiftRL# :: Int# -> Int# -> Int#
build :: (forall b. (a -> b -> b) -> b -> b) -> [a]
augment :: (forall b. (a -> b -> b) -> b -> b) -> [a] -> [a]
breakpoint :: a -> a
breakpointCond :: Bool -> a -> a
unIO :: IO a -> State# RealWorld -> (# State# RealWorld, a #)
remInt :: Int -> Int -> Int
ord :: Char -> Int
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
liftA :: Applicative f => (a -> b) -> f a -> f b
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
mapFB :: (elt -> lst -> lst) -> (a -> elt) -> a -> lst -> lst
unsafeChr :: Int -> Char
eqString :: String -> String -> Bool
maxInt :: Int
minInt :: Int
data Opaque = O a
until :: (a -> Bool) -> (a -> a) -> a -> a
asTypeOf :: a -> a -> a
returnIO :: a -> IO a
thenIO :: IO a -> IO b -> IO b
bindIO :: IO a -> (a -> IO b) -> IO b
getTag :: forall {lev :: Levity} (a :: TYPE ('BoxedRep lev)). DataToTag a => a -> Int#
quotInt :: Int -> Int -> Int
divInt :: Int -> Int -> Int
modInt :: Int -> Int -> Int
quotRemInt :: Int -> Int -> (Int, Int)
divModInt :: Int -> Int -> (Int, Int)
shift_mask :: Int# -> Int# -> Int#
class IP (x :: Symbol) a | x -> a where
- ip :: a
modInt# :: Int# -> Int# -> Int#
divInt# :: Int# -> Int# -> Int#
class Eq a where
- (==) :: a -> a -> Bool
- (/=) :: a -> a -> Bool
class Eq a => Ord a where
- compare :: a -> a -> Ordering
- (<) :: a -> a -> Bool
- (<=) :: a -> a -> Bool
- (>) :: a -> a -> Bool
- (>=) :: a -> a -> Bool
- max :: a -> a -> a
- min :: a -> a -> a
eqWord :: Word -> Word -> Bool
neWord :: Word -> Word -> Bool
eqChar :: Char -> Char -> Bool
neChar :: Char -> Char -> Bool
eqFloat :: Float -> Float -> Bool
eqDouble :: Double -> Double -> Bool
eqInt :: Int -> Int -> Bool
neInt :: Int -> Int -> Bool
gtInt :: Int -> Int -> Bool
geInt :: Int -> Int -> Bool
ltInt :: Int -> Int -> Bool
leInt :: Int -> Int -> Bool
compareInt :: Int -> Int -> Ordering
compareInt# :: Int# -> Int# -> Ordering
gtWord :: Word -> Word -> Bool
geWord :: Word -> Word -> Bool
ltWord :: Word -> Word -> Bool
leWord :: Word -> Word -> Bool
compareWord :: Word -> Word -> Ordering
compareWord# :: Word# -> Word# -> Ordering
(&&) :: Bool -> Bool -> Bool
(||) :: Bool -> Bool -> Bool
not :: Bool -> Bool
divInt8# :: Int8# -> Int8# -> Int8#
divInt16# :: Int16# -> Int16# -> Int16#
divInt32# :: Int32# -> Int32# -> Int32#
modInt8# :: Int8# -> Int8# -> Int8#
modInt16# :: Int16# -> Int16# -> Int16#
modInt32# :: Int32# -> Int32# -> Int32#
divModInt# :: Int# -> Int# -> (# Int#, Int# #)
divModInt8# :: Int8# -> Int8# -> (# Int8#, Int8# #)
divModInt16# :: Int16# -> Int16# -> (# Int16#, Int16# #)
divModInt32# :: Int32# -> Int32# -> (# Int32#, Int32# #)
module GHC.CString
module GHC.Magic
module GHC.Magic.Dict
data Word = W# Word#
data Float = F# Float#
data Int = I# Int#
data TYPE (a :: RuntimeRep)
data CONSTRAINT (a :: RuntimeRep)
data WordBox (a :: TYPE 'WordRep) = MkWordBox a
data IntBox (a :: TYPE 'IntRep) = MkIntBox a
data FloatBox (a :: TYPE 'FloatRep) = MkFloatBox a
data DoubleBox (a :: TYPE 'DoubleRep) = MkDoubleBox a
data DictBox a = a => MkDictBox
data Bool
- = False
- | True
data Char = C# Char#
data Double = D# Double#
data List a
data Ordering
- = LT
- | EQ
- | GT
class a ~# b => (a :: k0) ~~ (b :: k1)
class a ~# b => (a :: k) ~ (b :: k)
class a ~R# b => Coercible (a :: k) (b :: k)
data Symbol
data RuntimeRep
- = VecRep VecCount VecElem
- | TupleRep [RuntimeRep]
- | SumRep [RuntimeRep]
- | BoxedRep Levity
- | IntRep
- | Int8Rep
- | Int16Rep
- | Int32Rep
- | Int64Rep
- | WordRep
- | Word8Rep
- | Word16Rep
- | Word32Rep
- | Word64Rep
- | AddrRep
- | FloatRep
- | DoubleRep
data Levity
- = Lifted
- | Unlifted
data VecCount
- = Vec2
- | Vec4
- | Vec8
- | Vec16
- | Vec32
- | Vec64
data VecElem
- = Int8ElemRep
- | Int16ElemRep
- | Int32ElemRep
- | Int64ElemRep
- | Word8ElemRep
- | Word16ElemRep
- | Word32ElemRep
- | Word64ElemRep
- | FloatElemRep
- | DoubleElemRep
data Multiplicity
- = One
- | Many
data SPEC
- = SPEC
- | SPEC2
data TypeLitSort
- = TypeLitSymbol
- | TypeLitNat
- | TypeLitChar
data KindRep
- = KindRepTyConApp TyCon [KindRep]
- | KindRepVar !KindBndr
- | KindRepApp KindRep KindRep
- | KindRepFun KindRep KindRep
- | KindRepTYPE !RuntimeRep
- | KindRepTypeLitS TypeLitSort Addr#
- | KindRepTypeLitD TypeLitSort [Char]
data TyCon = TyCon Word64# Word64# Module TrName Int# KindRep
data TrName
- = TrNameS Addr#
- | TrNameD [Char]
data Module = Module TrName TrName
newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))
type ZeroBitType = TYPE ZeroBitRep
type ZeroBitRep = 'TupleRep ('[] :: [RuntimeRep])
type UnliftedRep = 'BoxedRep 'Unlifted
type LiftedRep = 'BoxedRep 'Lifted
type UnliftedType = TYPE UnliftedRep
type Type = TYPE LiftedRep
type Constraint = CONSTRAINT LiftedRep
type family Any :: k where ...
type KindBndr = Int
type Void# = (# #)
type family MultMul (a :: Multiplicity) (b :: Multiplicity) :: Multiplicity where ...
isTrue# :: Int# -> Bool
data Word# :: TYPE 'WordRep
data Int# :: TYPE 'IntRep
data Addr# :: TYPE 'AddrRep
data Array# (a :: TYPE ('BoxedRep l)) :: UnliftedType
data ByteArray# :: UnliftedType
data SmallArray# (a :: TYPE ('BoxedRep l)) :: UnliftedType
data Char# :: TYPE 'WordRep
data Double# :: TYPE 'DoubleRep
data Float# :: TYPE 'FloatRep
data Int8# :: TYPE 'Int8Rep
data Int16# :: TYPE 'Int16Rep
data Int32# :: TYPE 'Int32Rep
data Int64# :: TYPE 'Int64Rep
data BCO
data Weak# (a :: TYPE ('BoxedRep l)) :: UnliftedType
data MutableArray# a (b :: TYPE ('BoxedRep l)) :: UnliftedType
data MutableByteArray# a :: UnliftedType
data SmallMutableArray# a (b :: TYPE ('BoxedRep l)) :: UnliftedType
data MVar# a (b :: TYPE ('BoxedRep l)) :: UnliftedType
data IOPort# a (b :: TYPE ('BoxedRep l)) :: UnliftedType
data TVar# a (b :: TYPE ('BoxedRep l)) :: UnliftedType
data MutVar# a (b :: TYPE ('BoxedRep l)) :: UnliftedType
data RealWorld
data StablePtr# (a :: TYPE ('BoxedRep l)) :: TYPE 'AddrRep
data StableName# (a :: TYPE ('BoxedRep l)) :: UnliftedType
data Compact# :: UnliftedType
data State# a :: ZeroBitType
data Proxy# (a :: k) :: ZeroBitType
data ThreadId# :: UnliftedType
data Word8# :: TYPE 'Word8Rep
data Word16# :: TYPE 'Word16Rep
data Word32# :: TYPE 'Word32Rep
data Word64# :: TYPE 'Word64Rep
data StackSnapshot# :: UnliftedType
data PromptTag# a :: UnliftedType
data FUN
data TYPE (a :: RuntimeRep)
data CONSTRAINT (a :: RuntimeRep)
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)
prefetchValue0# :: a -> State# d -> State# d
prefetchAddr0# :: Addr# -> Int# -> State# d -> State# d
prefetchMutableByteArray0# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchByteArray0# :: ByteArray# -> Int# -> State# d -> State# d
prefetchValue1# :: a -> State# d -> State# d
prefetchAddr1# :: Addr# -> Int# -> State# d -> State# d
prefetchMutableByteArray1# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchByteArray1# :: ByteArray# -> Int# -> State# d -> State# d
prefetchValue2# :: a -> State# d -> State# d
prefetchAddr2# :: Addr# -> Int# -> State# d -> State# d
prefetchMutableByteArray2# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchByteArray2# :: ByteArray# -> Int# -> State# d -> State# d
prefetchValue3# :: a -> State# d -> State# d
prefetchAddr3# :: Addr# -> Int# -> State# d -> State# d
prefetchMutableByteArray3# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchByteArray3# :: ByteArray# -> Int# -> State# d -> State# d
writeDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -> State# d -> State# d
writeFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -> State# d -> State# d
writeDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -> State# d -> State# d
writeFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -> State# d -> State# d
writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# d -> State# d
writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# d -> State# d
writeWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -> State# d -> State# d
writeWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -> State# d -> State# d
writeWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -> State# d -> State# d
writeWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -> State# d -> State# d
writeWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -> State# d -> State# d
writeWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -> State# d -> State# d
writeWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -> State# d -> State# d
writeWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -> State# d -> State# d
writeWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -> State# d -> State# d
writeWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -> State# d -> State# d
writeWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -> State# d -> State# d
writeWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -> State# d -> State# d
writeInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -> State# d -> State# d
writeInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -> State# d -> State# d
writeInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -> State# d -> State# d
writeInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -> State# d -> State# d
writeInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -> State# d -> State# d
writeInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -> State# d -> State# d
writeInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -> State# d -> State# d
writeInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -> State# d -> State# d
writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# d -> State# d
writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# d -> State# d
writeInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -> State# d -> State# d
writeInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -> State# d -> State# d
readDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)
readFloatOffAddrAsFloatX16# :: Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)
readDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)
readFloatOffAddrAsFloatX8# :: Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)
readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)
readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)
readWord64OffAddrAsWord64X8# :: Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)
readWord32OffAddrAsWord32X16# :: Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)
readWord16OffAddrAsWord16X32# :: Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)
readWord8OffAddrAsWord8X64# :: Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)
readWord64OffAddrAsWord64X4# :: Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)
readWord32OffAddrAsWord32X8# :: Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)
readWord16OffAddrAsWord16X16# :: Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)
readWord8OffAddrAsWord8X32# :: Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)
readWord64OffAddrAsWord64X2# :: Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)
readWord32OffAddrAsWord32X4# :: Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)
readWord16OffAddrAsWord16X8# :: Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)
readWord8OffAddrAsWord8X16# :: Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)
readInt64OffAddrAsInt64X8# :: Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)
readInt32OffAddrAsInt32X16# :: Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)
readInt16OffAddrAsInt16X32# :: Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)
readInt8OffAddrAsInt8X64# :: Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)
readInt64OffAddrAsInt64X4# :: Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)
readInt32OffAddrAsInt32X8# :: Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)
readInt16OffAddrAsInt16X16# :: Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)
readInt8OffAddrAsInt8X32# :: Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)
readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)
readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)
readInt16OffAddrAsInt16X8# :: Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)
readInt8OffAddrAsInt8X16# :: Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)
indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8#
indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16#
indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4#
indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8#
indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2#
indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4#
indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8#
indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16#
indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32#
indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64#
indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4#
indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8#
indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16#
indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32#
indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2#
indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4#
indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8#
indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16#
indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8#
indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16#
indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32#
indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64#
indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4#
indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8#
indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16#
indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32#
indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2#
indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4#
indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8#
indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16#
writeDoubleArrayAsDoubleX8# :: MutableByteArray# d -> Int# -> DoubleX8# -> State# d -> State# d
writeFloatArrayAsFloatX16# :: MutableByteArray# d -> Int# -> FloatX16# -> State# d -> State# d
writeDoubleArrayAsDoubleX4# :: MutableByteArray# d -> Int# -> DoubleX4# -> State# d -> State# d
writeFloatArrayAsFloatX8# :: MutableByteArray# d -> Int# -> FloatX8# -> State# d -> State# d
writeDoubleArrayAsDoubleX2# :: MutableByteArray# d -> Int# -> DoubleX2# -> State# d -> State# d
writeFloatArrayAsFloatX4# :: MutableByteArray# d -> Int# -> FloatX4# -> State# d -> State# d
writeWord64ArrayAsWord64X8# :: MutableByteArray# d -> Int# -> Word64X8# -> State# d -> State# d
writeWord32ArrayAsWord32X16# :: MutableByteArray# d -> Int# -> Word32X16# -> State# d -> State# d
writeWord16ArrayAsWord16X32# :: MutableByteArray# d -> Int# -> Word16X32# -> State# d -> State# d
writeWord8ArrayAsWord8X64# :: MutableByteArray# d -> Int# -> Word8X64# -> State# d -> State# d
writeWord64ArrayAsWord64X4# :: MutableByteArray# d -> Int# -> Word64X4# -> State# d -> State# d
writeWord32ArrayAsWord32X8# :: MutableByteArray# d -> Int# -> Word32X8# -> State# d -> State# d
writeWord16ArrayAsWord16X16# :: MutableByteArray# d -> Int# -> Word16X16# -> State# d -> State# d
writeWord8ArrayAsWord8X32# :: MutableByteArray# d -> Int# -> Word8X32# -> State# d -> State# d
writeWord64ArrayAsWord64X2# :: MutableByteArray# d -> Int# -> Word64X2# -> State# d -> State# d
writeWord32ArrayAsWord32X4# :: MutableByteArray# d -> Int# -> Word32X4# -> State# d -> State# d
writeWord16ArrayAsWord16X8# :: MutableByteArray# d -> Int# -> Word16X8# -> State# d -> State# d
writeWord8ArrayAsWord8X16# :: MutableByteArray# d -> Int# -> Word8X16# -> State# d -> State# d
writeInt64ArrayAsInt64X8# :: MutableByteArray# d -> Int# -> Int64X8# -> State# d -> State# d
writeInt32ArrayAsInt32X16# :: MutableByteArray# d -> Int# -> Int32X16# -> State# d -> State# d
writeInt16ArrayAsInt16X32# :: MutableByteArray# d -> Int# -> Int16X32# -> State# d -> State# d
writeInt8ArrayAsInt8X64# :: MutableByteArray# d -> Int# -> Int8X64# -> State# d -> State# d
writeInt64ArrayAsInt64X4# :: MutableByteArray# d -> Int# -> Int64X4# -> State# d -> State# d
writeInt32ArrayAsInt32X8# :: MutableByteArray# d -> Int# -> Int32X8# -> State# d -> State# d
writeInt16ArrayAsInt16X16# :: MutableByteArray# d -> Int# -> Int16X16# -> State# d -> State# d
writeInt8ArrayAsInt8X32# :: MutableByteArray# d -> Int# -> Int8X32# -> State# d -> State# d
writeInt64ArrayAsInt64X2# :: MutableByteArray# d -> Int# -> Int64X2# -> State# d -> State# d
writeInt32ArrayAsInt32X4# :: MutableByteArray# d -> Int# -> Int32X4# -> State# d -> State# d
writeInt16ArrayAsInt16X8# :: MutableByteArray# d -> Int# -> Int16X8# -> State# d -> State# d
writeInt8ArrayAsInt8X16# :: MutableByteArray# d -> Int# -> Int8X16# -> State# d -> State# d
readDoubleArrayAsDoubleX8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)
readFloatArrayAsFloatX16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)
readDoubleArrayAsDoubleX4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)
readFloatArrayAsFloatX8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)
readDoubleArrayAsDoubleX2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)
readFloatArrayAsFloatX4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)
readWord64ArrayAsWord64X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)
readWord32ArrayAsWord32X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)
readWord16ArrayAsWord16X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)
readWord8ArrayAsWord8X64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)
readWord64ArrayAsWord64X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)
readWord32ArrayAsWord32X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)
readWord16ArrayAsWord16X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)
readWord8ArrayAsWord8X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)
readWord64ArrayAsWord64X2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)
readWord32ArrayAsWord32X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)
readWord16ArrayAsWord16X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)
readWord8ArrayAsWord8X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)
readInt64ArrayAsInt64X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)
readInt32ArrayAsInt32X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)
readInt16ArrayAsInt16X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)
readInt8ArrayAsInt8X64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)
readInt64ArrayAsInt64X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)
readInt32ArrayAsInt32X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)
readInt16ArrayAsInt16X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)
readInt8ArrayAsInt8X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)
readInt64ArrayAsInt64X2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)
readInt32ArrayAsInt32X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)
readInt16ArrayAsInt16X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)
readInt8ArrayAsInt8X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)
indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8#
indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16#
indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4#
indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8#
indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2#
indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4#
indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8#
indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16#
indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32#
indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64#
indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4#
indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8#
indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16#
indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32#
indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2#
indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4#
indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8#
indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16#
indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8#
indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16#
indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32#
indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64#
indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4#
indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8#
indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16#
indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32#
indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2#
indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4#
indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8#
indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16#
writeDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -> State# d -> State# d
writeFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -> State# d -> State# d
writeDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -> State# d -> State# d
writeFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -> State# d -> State# d
writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# d -> State# d
writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# d -> State# d
writeWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -> State# d -> State# d
writeWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -> State# d -> State# d
writeWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -> State# d -> State# d
writeWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -> State# d -> State# d
writeWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -> State# d -> State# d
writeWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -> State# d -> State# d
writeWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -> State# d -> State# d
writeWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -> State# d -> State# d
writeWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -> State# d -> State# d
writeWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -> State# d -> State# d
writeWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -> State# d -> State# d
writeWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -> State# d -> State# d
writeInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -> State# d -> State# d
writeInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -> State# d -> State# d
writeInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -> State# d -> State# d
writeInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -> State# d -> State# d
writeInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -> State# d -> State# d
writeInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -> State# d -> State# d
writeInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -> State# d -> State# d
writeInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -> State# d -> State# d
writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# d -> State# d
writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# d -> State# d
writeInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -> State# d -> State# d
writeInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -> State# d -> State# d
readDoubleX8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)
readFloatX16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)
readDoubleX4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)
readFloatX8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)
readDoubleX2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)
readFloatX4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)
readWord64X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)
readWord32X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)
readWord16X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)
readWord8X64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)
readWord64X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)
readWord32X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)
readWord16X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)
readWord8X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)
readWord64X2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)
readWord32X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)
readWord16X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)
readWord8X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)
readInt64X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)
readInt32X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)
readInt16X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)
readInt8X64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)
readInt64X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)
readInt32X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)
readInt16X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)
readInt8X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)
readInt64X2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)
readInt32X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)
readInt16X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)
readInt8X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)
indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8#
indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16#
indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4#
indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8#
indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2#
indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4#
indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8#
indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16#
indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32#
indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64#
indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4#
indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8#
indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16#
indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32#
indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2#
indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4#
indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8#
indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16#
indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8#
indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16#
indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32#
indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64#
indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4#
indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8#
indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16#
indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32#
indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2#
indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4#
indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8#
indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16#
writeDoubleX8Array# :: MutableByteArray# d -> Int# -> DoubleX8# -> State# d -> State# d
writeFloatX16Array# :: MutableByteArray# d -> Int# -> FloatX16# -> State# d -> State# d
writeDoubleX4Array# :: MutableByteArray# d -> Int# -> DoubleX4# -> State# d -> State# d
writeFloatX8Array# :: MutableByteArray# d -> Int# -> FloatX8# -> State# d -> State# d
writeDoubleX2Array# :: MutableByteArray# d -> Int# -> DoubleX2# -> State# d -> State# d
writeFloatX4Array# :: MutableByteArray# d -> Int# -> FloatX4# -> State# d -> State# d
writeWord64X8Array# :: MutableByteArray# d -> Int# -> Word64X8# -> State# d -> State# d
writeWord32X16Array# :: MutableByteArray# d -> Int# -> Word32X16# -> State# d -> State# d
writeWord16X32Array# :: MutableByteArray# d -> Int# -> Word16X32# -> State# d -> State# d
writeWord8X64Array# :: MutableByteArray# d -> Int# -> Word8X64# -> State# d -> State# d
writeWord64X4Array# :: MutableByteArray# d -> Int# -> Word64X4# -> State# d -> State# d
writeWord32X8Array# :: MutableByteArray# d -> Int# -> Word32X8# -> State# d -> State# d
writeWord16X16Array# :: MutableByteArray# d -> Int# -> Word16X16# -> State# d -> State# d
writeWord8X32Array# :: MutableByteArray# d -> Int# -> Word8X32# -> State# d -> State# d
writeWord64X2Array# :: MutableByteArray# d -> Int# -> Word64X2# -> State# d -> State# d
writeWord32X4Array# :: MutableByteArray# d -> Int# -> Word32X4# -> State# d -> State# d
writeWord16X8Array# :: MutableByteArray# d -> Int# -> Word16X8# -> State# d -> State# d
writeWord8X16Array# :: MutableByteArray# d -> Int# -> Word8X16# -> State# d -> State# d
writeInt64X8Array# :: MutableByteArray# d -> Int# -> Int64X8# -> State# d -> State# d
writeInt32X16Array# :: MutableByteArray# d -> Int# -> Int32X16# -> State# d -> State# d
writeInt16X32Array# :: MutableByteArray# d -> Int# -> Int16X32# -> State# d -> State# d
writeInt8X64Array# :: MutableByteArray# d -> Int# -> Int8X64# -> State# d -> State# d
writeInt64X4Array# :: MutableByteArray# d -> Int# -> Int64X4# -> State# d -> State# d
writeInt32X8Array# :: MutableByteArray# d -> Int# -> Int32X8# -> State# d -> State# d
writeInt16X16Array# :: MutableByteArray# d -> Int# -> Int16X16# -> State# d -> State# d
writeInt8X32Array# :: MutableByteArray# d -> Int# -> Int8X32# -> State# d -> State# d
writeInt64X2Array# :: MutableByteArray# d -> Int# -> Int64X2# -> State# d -> State# d
writeInt32X4Array# :: MutableByteArray# d -> Int# -> Int32X4# -> State# d -> State# d
writeInt16X8Array# :: MutableByteArray# d -> Int# -> Int16X8# -> State# d -> State# d
writeInt8X16Array# :: MutableByteArray# d -> Int# -> Int8X16# -> State# d -> State# d
readDoubleX8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)
readFloatX16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)
readDoubleX4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)
readFloatX8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)
readDoubleX2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)
readFloatX4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)
readWord64X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)
readWord32X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)
readWord16X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)
readWord8X64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)
readWord64X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)
readWord32X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)
readWord16X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)
readWord8X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)
readWord64X2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)
readWord32X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)
readWord16X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)
readWord8X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)
readInt64X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)
readInt32X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)
readInt16X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)
readInt8X64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)
readInt64X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)
readInt32X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)
readInt16X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)
readInt8X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)
readInt64X2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)
readInt32X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)
readInt16X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)
readInt8X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)
indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8#
indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16#
indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4#
indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8#
indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2#
indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4#
indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8#
indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16#
indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32#
indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64#
indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4#
indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8#
indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16#
indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32#
indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2#
indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4#
indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8#
indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16#
indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8#
indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16#
indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32#
indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64#
indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4#
indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8#
indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16#
indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32#
indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2#
indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4#
indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8#
indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16#
negateDoubleX8# :: DoubleX8# -> DoubleX8#
negateFloatX16# :: FloatX16# -> FloatX16#
negateDoubleX4# :: DoubleX4# -> DoubleX4#
negateFloatX8# :: FloatX8# -> FloatX8#
negateDoubleX2# :: DoubleX2# -> DoubleX2#
negateFloatX4# :: FloatX4# -> FloatX4#
negateInt64X8# :: Int64X8# -> Int64X8#
negateInt32X16# :: Int32X16# -> Int32X16#
negateInt16X32# :: Int16X32# -> Int16X32#
negateInt8X64# :: Int8X64# -> Int8X64#
negateInt64X4# :: Int64X4# -> Int64X4#
negateInt32X8# :: Int32X8# -> Int32X8#
negateInt16X16# :: Int16X16# -> Int16X16#
negateInt8X32# :: Int8X32# -> Int8X32#
negateInt64X2# :: Int64X2# -> Int64X2#
negateInt32X4# :: Int32X4# -> Int32X4#
negateInt16X8# :: Int16X8# -> Int16X8#
negateInt8X16# :: Int8X16# -> Int8X16#
remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8#
insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16#
insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4#
insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8#
insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2#
insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4#
insertWord64X8# :: Word64X8# -> Word64# -> Int# -> Word64X8#
insertWord32X16# :: Word32X16# -> Word32# -> Int# -> Word32X16#
insertWord16X32# :: Word16X32# -> Word16# -> Int# -> Word16X32#
insertWord8X64# :: Word8X64# -> Word8# -> Int# -> Word8X64#
insertWord64X4# :: Word64X4# -> Word64# -> Int# -> Word64X4#
insertWord32X8# :: Word32X8# -> Word32# -> Int# -> Word32X8#
insertWord16X16# :: Word16X16# -> Word16# -> Int# -> Word16X16#
insertWord8X32# :: Word8X32# -> Word8# -> Int# -> Word8X32#
insertWord64X2# :: Word64X2# -> Word64# -> Int# -> Word64X2#
insertWord32X4# :: Word32X4# -> Word32# -> Int# -> Word32X4#
insertWord16X8# :: Word16X8# -> Word16# -> Int# -> Word16X8#
insertWord8X16# :: Word8X16# -> Word8# -> Int# -> Word8X16#
insertInt64X8# :: Int64X8# -> Int64# -> Int# -> Int64X8#
insertInt32X16# :: Int32X16# -> Int32# -> Int# -> Int32X16#
insertInt16X32# :: Int16X32# -> Int16# -> Int# -> Int16X32#
insertInt8X64# :: Int8X64# -> Int8# -> Int# -> Int8X64#
insertInt64X4# :: Int64X4# -> Int64# -> Int# -> Int64X4#
insertInt32X8# :: Int32X8# -> Int32# -> Int# -> Int32X8#
insertInt16X16# :: Int16X16# -> Int16# -> Int# -> Int16X16#
insertInt8X32# :: Int8X32# -> Int8# -> Int# -> Int8X32#
insertInt64X2# :: Int64X2# -> Int64# -> Int# -> Int64X2#
insertInt32X4# :: Int32X4# -> Int32# -> Int# -> Int32X4#
insertInt16X8# :: Int16X8# -> Int16# -> Int# -> Int16X8#
insertInt8X16# :: Int8X16# -> Int8# -> Int# -> Int8X16#
unpackDoubleX8# :: DoubleX8# -> (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #)
unpackFloatX16# :: FloatX16# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)
unpackDoubleX4# :: DoubleX4# -> (# Double#, Double#, Double#, Double# #)
unpackFloatX8# :: FloatX8# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)
unpackDoubleX2# :: DoubleX2# -> (# Double#, Double# #)
unpackFloatX4# :: FloatX4# -> (# Float#, Float#, Float#, Float# #)
unpackWord64X8# :: Word64X8# -> (# Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64# #)
unpackWord32X16# :: Word32X16# -> (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #)
unpackWord16X32# :: Word16X32# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)
unpackWord8X64# :: Word8X64# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)
unpackWord64X4# :: Word64X4# -> (# Word64#, Word64#, Word64#, Word64# #)
unpackWord32X8# :: Word32X8# -> (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #)
unpackWord16X16# :: Word16X16# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)
unpackWord8X32# :: Word8X32# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)
unpackWord64X2# :: Word64X2# -> (# Word64#, Word64# #)
unpackWord32X4# :: Word32X4# -> (# Word32#, Word32#, Word32#, Word32# #)
unpackWord16X8# :: Word16X8# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)
unpackWord8X16# :: Word8X16# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)
unpackInt64X8# :: Int64X8# -> (# Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64# #)
unpackInt32X16# :: Int32X16# -> (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #)
unpackInt16X32# :: Int16X32# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)
unpackInt8X64# :: Int8X64# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)
unpackInt64X4# :: Int64X4# -> (# Int64#, Int64#, Int64#, Int64# #)
unpackInt32X8# :: Int32X8# -> (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #)
unpackInt16X16# :: Int16X16# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)
unpackInt8X32# :: Int8X32# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)
unpackInt64X2# :: Int64X2# -> (# Int64#, Int64# #)
unpackInt32X4# :: Int32X4# -> (# Int32#, Int32#, Int32#, Int32# #)
unpackInt16X8# :: Int16X8# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)
unpackInt8X16# :: Int8X16# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)
packDoubleX8# :: (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #) -> DoubleX8#
packFloatX16# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX16#
packDoubleX4# :: (# Double#, Double#, Double#, Double# #) -> DoubleX4#
packFloatX8# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX8#
packDoubleX2# :: (# Double#, Double# #) -> DoubleX2#
packFloatX4# :: (# Float#, Float#, Float#, Float# #) -> FloatX4#
packWord64X8# :: (# Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64# #) -> Word64X8#
packWord32X16# :: (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #) -> Word32X16#
packWord16X32# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X32#
packWord8X64# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X64#
packWord64X4# :: (# Word64#, Word64#, Word64#, Word64# #) -> Word64X4#
packWord32X8# :: (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #) -> Word32X8#
packWord16X16# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X16#
packWord8X32# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X32#
packWord64X2# :: (# Word64#, Word64# #) -> Word64X2#
packWord32X4# :: (# Word32#, Word32#, Word32#, Word32# #) -> Word32X4#
packWord16X8# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X8#
packWord8X16# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X16#
packInt64X8# :: (# Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64# #) -> Int64X8#
packInt32X16# :: (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #) -> Int32X16#
packInt16X32# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X32#
packInt8X64# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X64#
packInt64X4# :: (# Int64#, Int64#, Int64#, Int64# #) -> Int64X4#
packInt32X8# :: (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #) -> Int32X8#
packInt16X16# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X16#
packInt8X32# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X32#
packInt64X2# :: (# Int64#, Int64# #) -> Int64X2#
packInt32X4# :: (# Int32#, Int32#, Int32#, Int32# #) -> Int32X4#
packInt16X8# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X8#
packInt8X16# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X16#
broadcastDoubleX8# :: Double# -> DoubleX8#
broadcastFloatX16# :: Float# -> FloatX16#
broadcastDoubleX4# :: Double# -> DoubleX4#
broadcastFloatX8# :: Float# -> FloatX8#
broadcastDoubleX2# :: Double# -> DoubleX2#
broadcastFloatX4# :: Float# -> FloatX4#
broadcastWord64X8# :: Word64# -> Word64X8#
broadcastWord32X16# :: Word32# -> Word32X16#
broadcastWord16X32# :: Word16# -> Word16X32#
broadcastWord8X64# :: Word8# -> Word8X64#
broadcastWord64X4# :: Word64# -> Word64X4#
broadcastWord32X8# :: Word32# -> Word32X8#
broadcastWord16X16# :: Word16# -> Word16X16#
broadcastWord8X32# :: Word8# -> Word8X32#
broadcastWord64X2# :: Word64# -> Word64X2#
broadcastWord32X4# :: Word32# -> Word32X4#
broadcastWord16X8# :: Word16# -> Word16X8#
broadcastWord8X16# :: Word8# -> Word8X16#
broadcastInt64X8# :: Int64# -> Int64X8#
broadcastInt32X16# :: Int32# -> Int32X16#
broadcastInt16X32# :: Int16# -> Int16X32#
broadcastInt8X64# :: Int8# -> Int8X64#
broadcastInt64X4# :: Int64# -> Int64X4#
broadcastInt32X8# :: Int32# -> Int32X8#
broadcastInt16X16# :: Int16# -> Int16X16#
broadcastInt8X32# :: Int8# -> Int8X32#
broadcastInt64X2# :: Int64# -> Int64X2#
broadcastInt32X4# :: Int32# -> Int32X4#
broadcastInt16X8# :: Int16# -> Int16X8#
broadcastInt8X16# :: Int8# -> Int8X16#
setThreadAllocationCounter# :: Int64# -> State# RealWorld -> State# RealWorld
traceMarker# :: Addr# -> State# d -> State# d
traceBinaryEvent# :: Addr# -> Int# -> State# d -> State# d
traceEvent# :: Addr# -> State# d -> State# d
clearCCS# :: (State# d -> (# State# d, a #)) -> State# d -> (# State# d, a #)
getCurrentCCS# :: a -> State# d -> (# State# d, Addr# #)
getCCSOf# :: a -> State# d -> (# State# d, Addr# #)
getApStackVal# :: a -> Int# -> (# Int#, b #)
closureSize# :: a -> Int#
unpackClosure# :: a -> (# Addr#, ByteArray#, Array# b #)
newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# d -> (# State# d, BCO #)
mkApUpd0# :: BCO -> (# a #)
anyToAddr# :: a -> State# RealWorld -> (# State# RealWorld, Addr# #)
addrToAny# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). Addr# -> (# a #)
tagToEnum# :: Int# -> a
keepAlive# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d b. a -> State# d -> (State# d -> b) -> b
numSparks# :: State# d -> (# State# d, Int# #)
getSpark# :: State# d -> (# State# d, Int#, a #)
seq# :: a -> State# d -> (# State# d, a #)
spark# :: a -> State# d -> (# State# d, a #)
par# :: a -> Int#
reallyUnsafePtrEquality# :: forall {l :: Levity} {k :: Levity} (a :: TYPE ('BoxedRep l)) (b :: TYPE ('BoxedRep k)). a -> b -> Int#
compactSize# :: Compact# -> State# RealWorld -> (# State# RealWorld, Word# #)
compactAddWithSharing# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, a #)
compactAdd# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, a #)
compactFixupPointers# :: Addr# -> Addr# -> State# RealWorld -> (# State# RealWorld, Compact#, Addr# #)
compactAllocateBlock# :: Word# -> Addr# -> State# RealWorld -> (# State# RealWorld, Addr# #)
compactGetNextBlock# :: Compact# -> Addr# -> State# RealWorld -> (# State# RealWorld, Addr#, Word# #)
compactGetFirstBlock# :: Compact# -> State# RealWorld -> (# State# RealWorld, Addr#, Word# #)
compactContainsAny# :: a -> State# RealWorld -> (# State# RealWorld, Int# #)
compactContains# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, Int# #)
compactResize# :: Compact# -> Word# -> State# RealWorld -> State# RealWorld
compactNew# :: Word# -> State# RealWorld -> (# State# RealWorld, Compact# #)
stableNameToInt# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). StableName# a -> Int#
makeStableName# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). a -> State# RealWorld -> (# State# RealWorld, StableName# a #)
eqStablePtr# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). StablePtr# a -> StablePtr# a -> Int#
deRefStablePtr# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)
makeStablePtr# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)
touch# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. a -> State# d -> State# d
finalizeWeak# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) b. Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, State# RealWorld -> (# State# RealWorld, b #) #)
deRefWeak# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, a #)
addCFinalizerToWeak# :: forall {k :: Levity} (b :: TYPE ('BoxedRep k)). Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# RealWorld -> (# State# RealWorld, Int# #)
mkWeakNoFinalizer# :: forall {l :: Levity} {k :: Levity} (a :: TYPE ('BoxedRep l)) (b :: TYPE ('BoxedRep k)). a -> b -> State# RealWorld -> (# State# RealWorld, Weak# b #)
mkWeak# :: forall {l :: Levity} {k :: Levity} (a :: TYPE ('BoxedRep l)) (b :: TYPE ('BoxedRep k)) c. a -> b -> (State# RealWorld -> (# State# RealWorld, c #)) -> State# RealWorld -> (# State# RealWorld, Weak# b #)
listThreads# :: State# RealWorld -> (# State# RealWorld, Array# ThreadId# #)
threadStatus# :: ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, Int#, Int# #)
threadLabel# :: ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, ByteArray# #)
noDuplicate# :: State# d -> State# d
isCurrentThreadBound# :: State# RealWorld -> (# State# RealWorld, Int# #)
labelThread# :: ThreadId# -> ByteArray# -> State# RealWorld -> State# RealWorld
myThreadId# :: State# RealWorld -> (# State# RealWorld, ThreadId# #)
yield# :: State# RealWorld -> State# RealWorld
killThread# :: ThreadId# -> a -> State# RealWorld -> State# RealWorld
forkOn# :: Int# -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
fork# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
waitWrite# :: Int# -> State# d -> State# d
waitRead# :: Int# -> State# d -> State# d
delay# :: Int# -> State# d -> State# d
writeIOPort# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). IOPort# d a -> a -> State# d -> (# State# d, Int# #)
readIOPort# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). IOPort# d a -> State# d -> (# State# d, a #)
newIOPort# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). State# d -> (# State# d, IOPort# d a #)
isEmptyMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MVar# d a -> State# d -> (# State# d, Int# #)
tryReadMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MVar# d a -> State# d -> (# State# d, Int#, a #)
readMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MVar# d a -> State# d -> (# State# d, a #)
tryPutMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MVar# d a -> a -> State# d -> (# State# d, Int# #)
putMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MVar# d a -> a -> State# d -> State# d
tryTakeMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MVar# d a -> State# d -> (# State# d, Int#, a #)
takeMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MVar# d a -> State# d -> (# State# d, a #)
newMVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). State# d -> (# State# d, MVar# d a #)
writeTVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). TVar# d a -> a -> State# d -> State# d
readTVarIO# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). TVar# d a -> State# d -> (# State# d, a #)
readTVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). TVar# d a -> State# d -> (# State# d, a #)
newTVar# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. a -> State# d -> (# State# d, TVar# d a #)
catchSTM# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) b. (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
catchRetry# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). (State# RealWorld -> (# State# RealWorld, a #)) -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
retry# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). State# RealWorld -> (# State# RealWorld, a #)
atomically# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
control0# :: PromptTag# a -> (((State# RealWorld -> (# State# RealWorld, b #)) -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, b #)
prompt# :: PromptTag# a -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
newPromptTag# :: State# RealWorld -> (# State# RealWorld, PromptTag# a #)
getMaskingState# :: State# RealWorld -> (# State# RealWorld, Int# #)
unmaskAsyncExceptions# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
maskUninterruptible# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
maskAsyncExceptions# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
raiseIO# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) b. a -> State# RealWorld -> (# State# RealWorld, b #)
raiseDivZero# :: (# #) -> b
raiseOverflow# :: (# #) -> b
raiseUnderflow# :: (# #) -> b
raise# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) b. a -> b
catch# :: forall {k :: Levity} a (b :: TYPE ('BoxedRep k)). (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
casMutVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutVar# d a -> a -> a -> State# d -> (# State# d, Int#, a #)
atomicModifyMutVar_# :: MutVar# d a -> (a -> a) -> State# d -> (# State# d, a, a #)
atomicModifyMutVar2# :: MutVar# d a -> (a -> c) -> State# d -> (# State# d, a, c #)
atomicSwapMutVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutVar# d a -> a -> State# d -> (# State# d, a #)
writeMutVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutVar# d a -> a -> State# d -> State# d
readMutVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutVar# d a -> State# d -> (# State# d, a #)
newMutVar# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. a -> State# d -> (# State# d, MutVar# d a #)
atomicWriteWordAddr# :: Addr# -> Word# -> State# d -> State# d
atomicReadWordAddr# :: Addr# -> State# d -> (# State# d, Word# #)
fetchXorWordAddr# :: Addr# -> Word# -> State# d -> (# State# d, Word# #)
fetchOrWordAddr# :: Addr# -> Word# -> State# d -> (# State# d, Word# #)
fetchNandWordAddr# :: Addr# -> Word# -> State# d -> (# State# d, Word# #)
fetchAndWordAddr# :: Addr# -> Word# -> State# d -> (# State# d, Word# #)
fetchSubWordAddr# :: Addr# -> Word# -> State# d -> (# State# d, Word# #)
fetchAddWordAddr# :: Addr# -> Word# -> State# d -> (# State# d, Word# #)
atomicCasWord64Addr# :: Addr# -> Word64# -> Word64# -> State# d -> (# State# d, Word64# #)
atomicCasWord32Addr# :: Addr# -> Word32# -> Word32# -> State# d -> (# State# d, Word32# #)
atomicCasWord16Addr# :: Addr# -> Word16# -> Word16# -> State# d -> (# State# d, Word16# #)
atomicCasWord8Addr# :: Addr# -> Word8# -> Word8# -> State# d -> (# State# d, Word8# #)
atomicCasWordAddr# :: Addr# -> Word# -> Word# -> State# d -> (# State# d, Word# #)
atomicCasAddrAddr# :: Addr# -> Addr# -> Addr# -> State# d -> (# State# d, Addr# #)
atomicExchangeWordAddr# :: Addr# -> Word# -> State# d -> (# State# d, Word# #)
atomicExchangeAddrAddr# :: Addr# -> Addr# -> State# d -> (# State# d, Addr# #)
writeWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64# -> State# d -> State# d
writeWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64# -> State# d -> State# d
writeWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32# -> State# d -> State# d
writeWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32# -> State# d -> State# d
writeWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16# -> State# d -> State# d
writeWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16# -> State# d -> State# d
writeWord8OffAddrAsStablePtr# :: Addr# -> Int# -> StablePtr# a -> State# d -> State# d
writeWord8OffAddrAsDouble# :: Addr# -> Int# -> Double# -> State# d -> State# d
writeWord8OffAddrAsFloat# :: Addr# -> Int# -> Float# -> State# d -> State# d
writeWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr# -> State# d -> State# d
writeWord8OffAddrAsWord# :: Addr# -> Int# -> Word# -> State# d -> State# d
writeWord8OffAddrAsInt# :: Addr# -> Int# -> Int# -> State# d -> State# d
writeWord8OffAddrAsWideChar# :: Addr# -> Int# -> Char# -> State# d -> State# d
writeWord8OffAddrAsChar# :: Addr# -> Int# -> Char# -> State# d -> State# d
writeWord64OffAddr# :: Addr# -> Int# -> Word64# -> State# d -> State# d
writeInt64OffAddr# :: Addr# -> Int# -> Int64# -> State# d -> State# d
writeWord32OffAddr# :: Addr# -> Int# -> Word32# -> State# d -> State# d
writeInt32OffAddr# :: Addr# -> Int# -> Int32# -> State# d -> State# d
writeWord16OffAddr# :: Addr# -> Int# -> Word16# -> State# d -> State# d
writeInt16OffAddr# :: Addr# -> Int# -> Int16# -> State# d -> State# d
writeWord8OffAddr# :: Addr# -> Int# -> Word8# -> State# d -> State# d
writeInt8OffAddr# :: Addr# -> Int# -> Int8# -> State# d -> State# d
writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# d -> State# d
writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# d -> State# d
writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# d -> State# d
writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# d -> State# d
writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d
writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d
writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# d -> State# d
writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# d -> State# d
readWord8OffAddrAsWord64# :: Addr# -> Int# -> State# d -> (# State# d, Word64# #)
readWord8OffAddrAsInt64# :: Addr# -> Int# -> State# d -> (# State# d, Int64# #)
readWord8OffAddrAsWord32# :: Addr# -> Int# -> State# d -> (# State# d, Word32# #)
readWord8OffAddrAsInt32# :: Addr# -> Int# -> State# d -> (# State# d, Int32# #)
readWord8OffAddrAsWord16# :: Addr# -> Int# -> State# d -> (# State# d, Word16# #)
readWord8OffAddrAsInt16# :: Addr# -> Int# -> State# d -> (# State# d, Int16# #)
readWord8OffAddrAsStablePtr# :: Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)
readWord8OffAddrAsDouble# :: Addr# -> Int# -> State# d -> (# State# d, Double# #)
readWord8OffAddrAsFloat# :: Addr# -> Int# -> State# d -> (# State# d, Float# #)
readWord8OffAddrAsAddr# :: Addr# -> Int# -> State# d -> (# State# d, Addr# #)
readWord8OffAddrAsWord# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)
readWord8OffAddrAsInt# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)
readWord8OffAddrAsWideChar# :: Addr# -> Int# -> State# d -> (# State# d, Char# #)
readWord8OffAddrAsChar# :: Addr# -> Int# -> State# d -> (# State# d, Char# #)
readWord64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64# #)
readInt64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64# #)
readWord32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32# #)
readInt32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32# #)
readWord16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16# #)
readInt16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16# #)
readWord8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8# #)
readInt8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8# #)
readStablePtrOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)
readDoubleOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Double# #)
readFloatOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Float# #)
readAddrOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Addr# #)
readWordOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)
readIntOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)
readWideCharOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Char# #)
readCharOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Char# #)
indexWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64#
indexWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64#
indexWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32#
indexWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32#
indexWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16#
indexWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16#
indexWord8OffAddrAsStablePtr# :: Addr# -> Int# -> StablePtr# a
indexWord8OffAddrAsDouble# :: Addr# -> Int# -> Double#
indexWord8OffAddrAsFloat# :: Addr# -> Int# -> Float#
indexWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr#
indexWord8OffAddrAsWord# :: Addr# -> Int# -> Word#
indexWord8OffAddrAsInt# :: Addr# -> Int# -> Int#
indexWord8OffAddrAsWideChar# :: Addr# -> Int# -> Char#
indexWord8OffAddrAsChar# :: Addr# -> Int# -> Char#
indexWord64OffAddr# :: Addr# -> Int# -> Word64#
indexInt64OffAddr# :: Addr# -> Int# -> Int64#
indexWord32OffAddr# :: Addr# -> Int# -> Word32#
indexInt32OffAddr# :: Addr# -> Int# -> Int32#
indexWord16OffAddr# :: Addr# -> Int# -> Word16#
indexInt16OffAddr# :: Addr# -> Int# -> Int16#
indexWord8OffAddr# :: Addr# -> Int# -> Word8#
indexInt8OffAddr# :: Addr# -> Int# -> Int8#
indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a
indexDoubleOffAddr# :: Addr# -> Int# -> Double#
indexFloatOffAddr# :: Addr# -> Int# -> Float#
indexAddrOffAddr# :: Addr# -> Int# -> Addr#
indexWordOffAddr# :: Addr# -> Int# -> Word#
indexIntOffAddr# :: Addr# -> Int# -> Int#
indexWideCharOffAddr# :: Addr# -> Int# -> Char#
indexCharOffAddr# :: Addr# -> Int# -> Char#
leAddr# :: Addr# -> Addr# -> Int#
ltAddr# :: Addr# -> Addr# -> Int#
neAddr# :: Addr# -> Addr# -> Int#
eqAddr# :: Addr# -> Addr# -> Int#
geAddr# :: Addr# -> Addr# -> Int#
gtAddr# :: Addr# -> Addr# -> Int#
int2Addr# :: Int# -> Addr#
addr2Int# :: Addr# -> Int#
remAddr# :: Addr# -> Int# -> Int#
minusAddr# :: Addr# -> Addr# -> Int#
plusAddr# :: Addr# -> Int# -> Addr#
fetchXorIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchOrIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchNandIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchAndIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchSubIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchAddIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
casInt64Array# :: MutableByteArray# d -> Int# -> Int64# -> Int64# -> State# d -> (# State# d, Int64# #)
casInt32Array# :: MutableByteArray# d -> Int# -> Int32# -> Int32# -> State# d -> (# State# d, Int32# #)
casInt16Array# :: MutableByteArray# d -> Int# -> Int16# -> Int16# -> State# d -> (# State# d, Int16# #)
casInt8Array# :: MutableByteArray# d -> Int# -> Int8# -> Int8# -> State# d -> (# State# d, Int8# #)
casIntArray# :: MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> (# State# d, Int# #)
atomicWriteIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
atomicReadIntArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
setAddrRange# :: Addr# -> Int# -> Int# -> State# RealWorld -> State# RealWorld
setByteArray# :: MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> State# d
copyAddrToAddrNonOverlapping# :: Addr# -> Addr# -> Int# -> State# RealWorld -> State# RealWorld
copyAddrToAddr# :: Addr# -> Addr# -> Int# -> State# RealWorld -> State# RealWorld
copyAddrToByteArray# :: Addr# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
copyMutableByteArrayToAddr# :: MutableByteArray# d -> Int# -> Addr# -> Int# -> State# d -> State# d
copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# d -> State# d
copyMutableByteArrayNonOverlapping# :: MutableByteArray# d -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
copyMutableByteArray# :: MutableByteArray# d -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
writeWord8ArrayAsWord64# :: MutableByteArray# d -> Int# -> Word64# -> State# d -> State# d
writeWord8ArrayAsInt64# :: MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d
writeWord8ArrayAsWord32# :: MutableByteArray# d -> Int# -> Word32# -> State# d -> State# d
writeWord8ArrayAsInt32# :: MutableByteArray# d -> Int# -> Int32# -> State# d -> State# d
writeWord8ArrayAsWord16# :: MutableByteArray# d -> Int# -> Word16# -> State# d -> State# d
writeWord8ArrayAsInt16# :: MutableByteArray# d -> Int# -> Int16# -> State# d -> State# d
writeWord8ArrayAsStablePtr# :: MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d
writeWord8ArrayAsDouble# :: MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeWord8ArrayAsFloat# :: MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeWord8ArrayAsAddr# :: MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
writeWord8ArrayAsWord# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord8ArrayAsInt# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeWord8ArrayAsWideChar# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
writeWord8ArrayAsChar# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
writeWord64Array# :: MutableByteArray# d -> Int# -> Word64# -> State# d -> State# d
writeInt64Array# :: MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d
writeWord32Array# :: MutableByteArray# d -> Int# -> Word32# -> State# d -> State# d
writeInt32Array# :: MutableByteArray# d -> Int# -> Int32# -> State# d -> State# d
writeWord16Array# :: MutableByteArray# d -> Int# -> Word16# -> State# d -> State# d
writeInt16Array# :: MutableByteArray# d -> Int# -> Int16# -> State# d -> State# d
writeWord8Array# :: MutableByteArray# d -> Int# -> Word8# -> State# d -> State# d
writeInt8Array# :: MutableByteArray# d -> Int# -> Int8# -> State# d -> State# d
writeStablePtrArray# :: MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d
writeDoubleArray# :: MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeFloatArray# :: MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeAddrArray# :: MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
writeWordArray# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeWideCharArray# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
writeCharArray# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
readWord8ArrayAsWord64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64# #)
readWord8ArrayAsInt64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
readWord8ArrayAsWord32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32# #)
readWord8ArrayAsInt32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32# #)
readWord8ArrayAsWord16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16# #)
readWord8ArrayAsInt16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16# #)
readWord8ArrayAsStablePtr# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
readWord8ArrayAsDouble# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readWord8ArrayAsFloat# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
readWord8ArrayAsAddr# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
readWord8ArrayAsWord# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord8ArrayAsInt# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readWord8ArrayAsWideChar# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
readWord8ArrayAsChar# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
readWord64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64# #)
readInt64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
readWord32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32# #)
readInt32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32# #)
readWord16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16# #)
readInt16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16# #)
readWord8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8# #)
readInt8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8# #)
readStablePtrArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
readDoubleArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readFloatArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
readAddrArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
readWordArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readIntArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readWideCharArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
readCharArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word64#
indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int64#
indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word32#
indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int32#
indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word16#
indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int16#
indexWord8ArrayAsStablePtr# :: ByteArray# -> Int# -> StablePtr# a
indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double#
indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float#
indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr#
indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word#
indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int#
indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char#
indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char#
indexWord64Array# :: ByteArray# -> Int# -> Word64#
indexInt64Array# :: ByteArray# -> Int# -> Int64#
indexWord32Array# :: ByteArray# -> Int# -> Word32#
indexInt32Array# :: ByteArray# -> Int# -> Int32#
indexWord16Array# :: ByteArray# -> Int# -> Word16#
indexInt16Array# :: ByteArray# -> Int# -> Int16#
indexWord8Array# :: ByteArray# -> Int# -> Word8#
indexInt8Array# :: ByteArray# -> Int# -> Int8#
indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a
indexDoubleArray# :: ByteArray# -> Int# -> Double#
indexFloatArray# :: ByteArray# -> Int# -> Float#
indexAddrArray# :: ByteArray# -> Int# -> Addr#
indexWordArray# :: ByteArray# -> Int# -> Word#
indexIntArray# :: ByteArray# -> Int# -> Int#
indexWideCharArray# :: ByteArray# -> Int# -> Char#
indexCharArray# :: ByteArray# -> Int# -> Char#
getSizeofMutableByteArray# :: MutableByteArray# d -> State# d -> (# State# d, Int# #)
sizeofMutableByteArray# :: MutableByteArray# d -> Int#
sizeofByteArray# :: ByteArray# -> Int#
unsafeThawByteArray# :: ByteArray# -> State# d -> (# State# d, MutableByteArray# d #)
unsafeFreezeByteArray# :: MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
resizeMutableByteArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
shrinkMutableByteArray# :: MutableByteArray# d -> Int# -> State# d -> State# d
mutableByteArrayContents# :: MutableByteArray# d -> Addr#
byteArrayContents# :: ByteArray# -> Addr#
isByteArrayPinned# :: ByteArray# -> Int#
isMutableByteArrayPinned# :: MutableByteArray# d -> Int#
newAlignedPinnedByteArray# :: Int# -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
newPinnedByteArray# :: Int# -> State# d -> (# State# d, MutableByteArray# d #)
newByteArray# :: Int# -> State# d -> (# State# d, MutableByteArray# d #)
casSmallArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int# -> a -> a -> State# d -> (# State# d, Int#, a #)
thawSmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. SmallArray# a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)
freezeSmallArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallArray# a #)
cloneSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)
cloneSmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). SmallArray# a -> Int# -> Int# -> SmallArray# a
copySmallMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int# -> SmallMutableArray# d a -> Int# -> Int# -> State# d -> State# d
copySmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. SmallArray# a -> Int# -> SmallMutableArray# d a -> Int# -> Int# -> State# d -> State# d
unsafeThawSmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. SmallArray# a -> State# d -> (# State# d, SmallMutableArray# d a #)
unsafeFreezeSmallArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> State# d -> (# State# d, SmallArray# a #)
indexSmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). SmallArray# a -> Int# -> (# a #)
getSizeofSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> State# d -> (# State# d, Int# #)
sizeofSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int#
sizeofSmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). SmallArray# a -> Int#
writeSmallArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int# -> a -> State# d -> State# d
readSmallArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int# -> State# d -> (# State# d, a #)
shrinkSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). SmallMutableArray# d a -> Int# -> State# d -> State# d
newSmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. Int# -> a -> State# d -> (# State# d, SmallMutableArray# d a #)
casArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> Int# -> a -> a -> State# d -> (# State# d, Int#, a #)
thawArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. Array# a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
freezeArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, Array# a #)
cloneMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
cloneArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). Array# a -> Int# -> Int# -> Array# a
copyMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> Int# -> MutableArray# d a -> Int# -> Int# -> State# d -> State# d
copyArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. Array# a -> Int# -> MutableArray# d a -> Int# -> Int# -> State# d -> State# d
unsafeThawArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. Array# a -> State# d -> (# State# d, MutableArray# d a #)
unsafeFreezeArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> State# d -> (# State# d, Array# a #)
indexArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). Array# a -> Int# -> (# a #)
sizeofMutableArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> Int#
sizeofArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). Array# a -> Int#
writeArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> Int# -> a -> State# d -> State# d
readArray# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutableArray# d a -> Int# -> State# d -> (# State# d, a #)
newArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. Int# -> a -> State# d -> (# State# d, MutableArray# d a #)
fnmsubDouble# :: Double# -> Double# -> Double# -> Double#
fnmaddDouble# :: Double# -> Double# -> Double# -> Double#
fmsubDouble# :: Double# -> Double# -> Double# -> Double#
fmaddDouble# :: Double# -> Double# -> Double# -> Double#
fnmsubFloat# :: Float# -> Float# -> Float# -> Float#
fnmaddFloat# :: Float# -> Float# -> Float# -> Float#
fmsubFloat# :: Float# -> Float# -> Float# -> Float#
fmaddFloat# :: Float# -> Float# -> Float# -> Float#
castWord32ToFloat# :: Word32# -> Float#
castFloatToWord32# :: Float# -> Word32#
decodeFloat_Int# :: Float# -> (# Int#, Int# #)
float2Double# :: Float# -> Double#
powerFloat# :: Float# -> Float# -> Float#
atanhFloat# :: Float# -> Float#
acoshFloat# :: Float# -> Float#
asinhFloat# :: Float# -> Float#
tanhFloat# :: Float# -> Float#
coshFloat# :: Float# -> Float#
sinhFloat# :: Float# -> Float#
atanFloat# :: Float# -> Float#
acosFloat# :: Float# -> Float#
asinFloat# :: Float# -> Float#
tanFloat# :: Float# -> Float#
cosFloat# :: Float# -> Float#
sinFloat# :: Float# -> Float#
sqrtFloat# :: Float# -> Float#
log1pFloat# :: Float# -> Float#
logFloat# :: Float# -> Float#
expm1Float# :: Float# -> Float#
expFloat# :: Float# -> Float#
float2Int# :: Float# -> Int#
fabsFloat# :: Float# -> Float#
negateFloat# :: Float# -> Float#
divideFloat# :: Float# -> Float# -> Float#
timesFloat# :: Float# -> Float# -> Float#
minusFloat# :: Float# -> Float# -> Float#
plusFloat# :: Float# -> Float# -> Float#
leFloat# :: Float# -> Float# -> Int#
ltFloat# :: Float# -> Float# -> Int#
neFloat# :: Float# -> Float# -> Int#
eqFloat# :: Float# -> Float# -> Int#
geFloat# :: Float# -> Float# -> Int#
gtFloat# :: Float# -> Float# -> Int#
castWord64ToDouble# :: Word64# -> Double#
castDoubleToWord64# :: Double# -> Word64#
decodeDouble_Int64# :: Double# -> (# Int64#, Int# #)
decodeDouble_2Int# :: Double# -> (# Int#, Word#, Word#, Int# #)
(**##) :: Double# -> Double# -> Double#
atanhDouble# :: Double# -> Double#
acoshDouble# :: Double# -> Double#
asinhDouble# :: Double# -> Double#
tanhDouble# :: Double# -> Double#
coshDouble# :: Double# -> Double#
sinhDouble# :: Double# -> Double#
atanDouble# :: Double# -> Double#
acosDouble# :: Double# -> Double#
asinDouble# :: Double# -> Double#
tanDouble# :: Double# -> Double#
cosDouble# :: Double# -> Double#
sinDouble# :: Double# -> Double#
sqrtDouble# :: Double# -> Double#
log1pDouble# :: Double# -> Double#
logDouble# :: Double# -> Double#
expm1Double# :: Double# -> Double#
expDouble# :: Double# -> Double#
double2Float# :: Double# -> Float#
double2Int# :: Double# -> Int#
fabsDouble# :: Double# -> Double#
negateDouble# :: Double# -> Double#
(/##) :: Double# -> Double# -> Double#
(*##) :: Double# -> Double# -> Double#
(-##) :: Double# -> Double# -> Double#
(+##) :: Double# -> Double# -> Double#
(<=##) :: Double# -> Double# -> Int#
(<##) :: Double# -> Double# -> Int#
(/=##) :: Double# -> Double# -> Int#
(==##) :: Double# -> Double# -> Int#
(>=##) :: Double# -> Double# -> Int#
(>##) :: Double# -> Double# -> Int#
narrow32Word# :: Word# -> Word#
narrow16Word# :: Word# -> Word#
narrow8Word# :: Word# -> Word#
narrow32Int# :: Int# -> Int#
narrow16Int# :: Int# -> Int#
narrow8Int# :: Int# -> Int#
bitReverse# :: Word# -> Word#
bitReverse64# :: Word64# -> Word64#
bitReverse32# :: Word# -> Word#
bitReverse16# :: Word# -> Word#
bitReverse8# :: Word# -> Word#
byteSwap# :: Word# -> Word#
byteSwap64# :: Word64# -> Word64#
byteSwap32# :: Word# -> Word#
byteSwap16# :: Word# -> Word#
ctz# :: Word# -> Word#
ctz64# :: Word64# -> Word#
ctz32# :: Word# -> Word#
ctz16# :: Word# -> Word#
ctz8# :: Word# -> Word#
clz# :: Word# -> Word#
clz64# :: Word64# -> Word#
clz32# :: Word# -> Word#
clz16# :: Word# -> Word#
clz8# :: Word# -> Word#
pext# :: Word# -> Word# -> Word#
pext64# :: Word64# -> Word64# -> Word64#
pext32# :: Word# -> Word# -> Word#
pext16# :: Word# -> Word# -> Word#
pext8# :: Word# -> Word# -> Word#
pdep# :: Word# -> Word# -> Word#
pdep64# :: Word64# -> Word64# -> Word64#
pdep32# :: Word# -> Word# -> Word#
pdep16# :: Word# -> Word# -> Word#
pdep8# :: Word# -> Word# -> Word#
popCnt# :: Word# -> Word#
popCnt64# :: Word64# -> Word#
popCnt32# :: Word# -> Word#
popCnt16# :: Word# -> Word#
popCnt8# :: Word# -> Word#
leWord# :: Word# -> Word# -> Int#
ltWord# :: Word# -> Word# -> Int#
neWord# :: Word# -> Word# -> Int#
eqWord# :: Word# -> Word# -> Int#
geWord# :: Word# -> Word# -> Int#
gtWord# :: Word# -> Word# -> Int#
word2Int# :: Word# -> Int#
uncheckedShiftRL# :: Word# -> Int# -> Word#
uncheckedShiftL# :: Word# -> Int# -> Word#
not# :: Word# -> Word#
xor# :: Word# -> Word# -> Word#
or# :: Word# -> Word# -> Word#
and# :: Word# -> Word# -> Word#
quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#, Word# #)
quotRemWord# :: Word# -> Word# -> (# Word#, Word# #)
remWord# :: Word# -> Word# -> Word#
quotWord# :: Word# -> Word# -> Word#
timesWord2# :: Word# -> Word# -> (# Word#, Word# #)
timesWord# :: Word# -> Word# -> Word#
minusWord# :: Word# -> Word# -> Word#
plusWord2# :: Word# -> Word# -> (# Word#, Word# #)
subWordC# :: Word# -> Word# -> (# Word#, Int# #)
addWordC# :: Word# -> Word# -> (# Word#, Int# #)
plusWord# :: Word# -> Word# -> Word#
uncheckedIShiftRL# :: Int# -> Int# -> Int#
uncheckedIShiftRA# :: Int# -> Int# -> Int#
uncheckedIShiftL# :: Int# -> Int# -> Int#
word2Double# :: Word# -> Double#
word2Float# :: Word# -> Float#
int2Double# :: Int# -> Double#
int2Float# :: Int# -> Float#
int2Word# :: Int# -> Word#
chr# :: Int# -> Char#
(<=#) :: Int# -> Int# -> Int#
(<#) :: Int# -> Int# -> Int#
(/=#) :: Int# -> Int# -> Int#
(==#) :: Int# -> Int# -> Int#
(>=#) :: Int# -> Int# -> Int#
(>#) :: Int# -> Int# -> Int#
subIntC# :: Int# -> Int# -> (# Int#, Int# #)
addIntC# :: Int# -> Int# -> (# Int#, Int# #)
negateInt# :: Int# -> Int#
notI# :: Int# -> Int#
xorI# :: Int# -> Int# -> Int#
orI# :: Int# -> Int# -> Int#
andI# :: Int# -> Int# -> Int#
quotRemInt# :: Int# -> Int# -> (# Int#, Int# #)
remInt# :: Int# -> Int# -> Int#
quotInt# :: Int# -> Int# -> Int#
mulIntMayOflo# :: Int# -> Int# -> Int#
timesInt2# :: Int# -> Int# -> (# Int#, Int#, Int# #)
(*#) :: Int# -> Int# -> Int#
(-#) :: Int# -> Int# -> Int#
(+#) :: Int# -> Int# -> Int#
neWord64# :: Word64# -> Word64# -> Int#
ltWord64# :: Word64# -> Word64# -> Int#
leWord64# :: Word64# -> Word64# -> Int#
gtWord64# :: Word64# -> Word64# -> Int#
geWord64# :: Word64# -> Word64# -> Int#
eqWord64# :: Word64# -> Word64# -> Int#
word64ToInt64# :: Word64# -> Int64#
uncheckedShiftRL64# :: Word64# -> Int# -> Word64#
uncheckedShiftL64# :: Word64# -> Int# -> Word64#
not64# :: Word64# -> Word64#
xor64# :: Word64# -> Word64# -> Word64#
or64# :: Word64# -> Word64# -> Word64#
and64# :: Word64# -> Word64# -> Word64#
remWord64# :: Word64# -> Word64# -> Word64#
quotWord64# :: Word64# -> Word64# -> Word64#
timesWord64# :: Word64# -> Word64# -> Word64#
subWord64# :: Word64# -> Word64# -> Word64#
plusWord64# :: Word64# -> Word64# -> Word64#
wordToWord64# :: Word# -> Word64#
word64ToWord# :: Word64# -> Word#
neInt64# :: Int64# -> Int64# -> Int#
ltInt64# :: Int64# -> Int64# -> Int#
leInt64# :: Int64# -> Int64# -> Int#
gtInt64# :: Int64# -> Int64# -> Int#
geInt64# :: Int64# -> Int64# -> Int#
eqInt64# :: Int64# -> Int64# -> Int#
int64ToWord64# :: Int64# -> Word64#
uncheckedIShiftRL64# :: Int64# -> Int# -> Int64#
uncheckedIShiftRA64# :: Int64# -> Int# -> Int64#
uncheckedIShiftL64# :: Int64# -> Int# -> Int64#
remInt64# :: Int64# -> Int64# -> Int64#
quotInt64# :: Int64# -> Int64# -> Int64#
timesInt64# :: Int64# -> Int64# -> Int64#
subInt64# :: Int64# -> Int64# -> Int64#
plusInt64# :: Int64# -> Int64# -> Int64#
negateInt64# :: Int64# -> Int64#
intToInt64# :: Int# -> Int64#
int64ToInt# :: Int64# -> Int#
neWord32# :: Word32# -> Word32# -> Int#
ltWord32# :: Word32# -> Word32# -> Int#
leWord32# :: Word32# -> Word32# -> Int#
gtWord32# :: Word32# -> Word32# -> Int#
geWord32# :: Word32# -> Word32# -> Int#
eqWord32# :: Word32# -> Word32# -> Int#
word32ToInt32# :: Word32# -> Int32#
uncheckedShiftRLWord32# :: Word32# -> Int# -> Word32#
uncheckedShiftLWord32# :: Word32# -> Int# -> Word32#
notWord32# :: Word32# -> Word32#
xorWord32# :: Word32# -> Word32# -> Word32#
orWord32# :: Word32# -> Word32# -> Word32#
andWord32# :: Word32# -> Word32# -> Word32#
quotRemWord32# :: Word32# -> Word32# -> (# Word32#, Word32# #)
remWord32# :: Word32# -> Word32# -> Word32#
quotWord32# :: Word32# -> Word32# -> Word32#
timesWord32# :: Word32# -> Word32# -> Word32#
subWord32# :: Word32# -> Word32# -> Word32#
plusWord32# :: Word32# -> Word32# -> Word32#
wordToWord32# :: Word# -> Word32#
word32ToWord# :: Word32# -> Word#
neInt32# :: Int32# -> Int32# -> Int#
ltInt32# :: Int32# -> Int32# -> Int#
leInt32# :: Int32# -> Int32# -> Int#
gtInt32# :: Int32# -> Int32# -> Int#
geInt32# :: Int32# -> Int32# -> Int#
eqInt32# :: Int32# -> Int32# -> Int#
int32ToWord32# :: Int32# -> Word32#
uncheckedShiftRLInt32# :: Int32# -> Int# -> Int32#
uncheckedShiftRAInt32# :: Int32# -> Int# -> Int32#
uncheckedShiftLInt32# :: Int32# -> Int# -> Int32#
quotRemInt32# :: Int32# -> Int32# -> (# Int32#, Int32# #)
remInt32# :: Int32# -> Int32# -> Int32#
quotInt32# :: Int32# -> Int32# -> Int32#
timesInt32# :: Int32# -> Int32# -> Int32#
subInt32# :: Int32# -> Int32# -> Int32#
plusInt32# :: Int32# -> Int32# -> Int32#
negateInt32# :: Int32# -> Int32#
intToInt32# :: Int# -> Int32#
int32ToInt# :: Int32# -> Int#
neWord16# :: Word16# -> Word16# -> Int#
ltWord16# :: Word16# -> Word16# -> Int#
leWord16# :: Word16# -> Word16# -> Int#
gtWord16# :: Word16# -> Word16# -> Int#
geWord16# :: Word16# -> Word16# -> Int#
eqWord16# :: Word16# -> Word16# -> Int#
word16ToInt16# :: Word16# -> Int16#
uncheckedShiftRLWord16# :: Word16# -> Int# -> Word16#
uncheckedShiftLWord16# :: Word16# -> Int# -> Word16#
notWord16# :: Word16# -> Word16#
xorWord16# :: Word16# -> Word16# -> Word16#
orWord16# :: Word16# -> Word16# -> Word16#
andWord16# :: Word16# -> Word16# -> Word16#
quotRemWord16# :: Word16# -> Word16# -> (# Word16#, Word16# #)
remWord16# :: Word16# -> Word16# -> Word16#
quotWord16# :: Word16# -> Word16# -> Word16#
timesWord16# :: Word16# -> Word16# -> Word16#
subWord16# :: Word16# -> Word16# -> Word16#
plusWord16# :: Word16# -> Word16# -> Word16#
wordToWord16# :: Word# -> Word16#
word16ToWord# :: Word16# -> Word#
neInt16# :: Int16# -> Int16# -> Int#
ltInt16# :: Int16# -> Int16# -> Int#
leInt16# :: Int16# -> Int16# -> Int#
gtInt16# :: Int16# -> Int16# -> Int#
geInt16# :: Int16# -> Int16# -> Int#
eqInt16# :: Int16# -> Int16# -> Int#
int16ToWord16# :: Int16# -> Word16#
uncheckedShiftRLInt16# :: Int16# -> Int# -> Int16#
uncheckedShiftRAInt16# :: Int16# -> Int# -> Int16#
uncheckedShiftLInt16# :: Int16# -> Int# -> Int16#
quotRemInt16# :: Int16# -> Int16# -> (# Int16#, Int16# #)
remInt16# :: Int16# -> Int16# -> Int16#
quotInt16# :: Int16# -> Int16# -> Int16#
timesInt16# :: Int16# -> Int16# -> Int16#
subInt16# :: Int16# -> Int16# -> Int16#
plusInt16# :: Int16# -> Int16# -> Int16#
negateInt16# :: Int16# -> Int16#
intToInt16# :: Int# -> Int16#
int16ToInt# :: Int16# -> Int#
neWord8# :: Word8# -> Word8# -> Int#
ltWord8# :: Word8# -> Word8# -> Int#
leWord8# :: Word8# -> Word8# -> Int#
gtWord8# :: Word8# -> Word8# -> Int#
geWord8# :: Word8# -> Word8# -> Int#
eqWord8# :: Word8# -> Word8# -> Int#
word8ToInt8# :: Word8# -> Int8#
uncheckedShiftRLWord8# :: Word8# -> Int# -> Word8#
uncheckedShiftLWord8# :: Word8# -> Int# -> Word8#
notWord8# :: Word8# -> Word8#
xorWord8# :: Word8# -> Word8# -> Word8#
orWord8# :: Word8# -> Word8# -> Word8#
andWord8# :: Word8# -> Word8# -> Word8#
quotRemWord8# :: Word8# -> Word8# -> (# Word8#, Word8# #)
remWord8# :: Word8# -> Word8# -> Word8#
quotWord8# :: Word8# -> Word8# -> Word8#
timesWord8# :: Word8# -> Word8# -> Word8#
subWord8# :: Word8# -> Word8# -> Word8#
plusWord8# :: Word8# -> Word8# -> Word8#
wordToWord8# :: Word# -> Word8#
word8ToWord# :: Word8# -> Word#
neInt8# :: Int8# -> Int8# -> Int#
ltInt8# :: Int8# -> Int8# -> Int#
leInt8# :: Int8# -> Int8# -> Int#
gtInt8# :: Int8# -> Int8# -> Int#
geInt8# :: Int8# -> Int8# -> Int#
eqInt8# :: Int8# -> Int8# -> Int#
int8ToWord8# :: Int8# -> Word8#
uncheckedShiftRLInt8# :: Int8# -> Int# -> Int8#
uncheckedShiftRAInt8# :: Int8# -> Int# -> Int8#
uncheckedShiftLInt8# :: Int8# -> Int# -> Int8#
quotRemInt8# :: Int8# -> Int8# -> (# Int8#, Int8# #)
remInt8# :: Int8# -> Int8# -> Int8#
quotInt8# :: Int8# -> Int8# -> Int8#
timesInt8# :: Int8# -> Int8# -> Int8#
subInt8# :: Int8# -> Int8# -> Int8#
plusInt8# :: Int8# -> Int8# -> Int8#
negateInt8# :: Int8# -> Int8#
intToInt8# :: Int# -> Int8#
int8ToInt# :: Int8# -> Int#
ord# :: Char# -> Int#
leChar# :: Char# -> Char# -> Int#
ltChar# :: Char# -> Char# -> Int#
neChar# :: Char# -> Char# -> Int#
eqChar# :: Char# -> Char# -> Int#
geChar# :: Char# -> Char# -> Int#
gtChar# :: Char# -> Char# -> Int#
rightSection :: forall {n :: Multiplicity} {o :: Multiplicity} a b c. (a %n -> b %o -> c) -> b %o -> a %n -> c
leftSection :: forall {n :: Multiplicity} a b. (a %n -> b) -> a %n -> b
proxy# :: forall {k} (a :: k). Proxy# a
coerce :: Coercible a b => a -> b
seq :: a -> b -> b
nullAddr# :: Addr#
void# :: (# #)
realWorld# :: State# RealWorld
module GHC.Prim.Ext
module GHC.Prim.PtrEq
module GHC.Internal.Err
module GHC.Internal.Maybe

Documentation

type String = [Char] Source #

String is an alias for a list of characters.

String constants in Haskell are values of type String. That means if you write a string literal like "hello world", it will have the type [Char], which is the same as String.

Note: You can ask the compiler to automatically infer different types with the -XOverloadedStrings language extension, for example "hello world" :: Text. See IsString for more information.

Because String is just a list of characters, you can use normal list functions to do basic string manipulation. See Data.List for operations on lists.

Performance considerations

Expand

[Char] is a relatively memory-inefficient type. It is a linked list of boxed word-size characters, internally it looks something like:

╭─────┬───┬──╮  ╭─────┬───┬──╮  ╭─────┬───┬──╮  ╭────╮
│ (:) │   │ ─┼─>│ (:) │   │ ─┼─>│ (:) │   │ ─┼─>│ [] │
╰─────┴─┼─┴──╯  ╰─────┴─┼─┴──╯  ╰─────┴─┼─┴──╯  ╰────╯
        v               v               v
       'a'             'b'             'c'

The String "abc" will use 5*3+1 = 16 (in general 5n+1) words of space in memory.

Furthermore, operations like (++) (string concatenation) are O(n) (in the left argument).

For historical reasons, the base library uses String in a lot of places for the conceptual simplicity, but library code dealing with user-data should use the text package for Unicode text, or the the bytestring package for binary data.

class Applicative m => Monad (m :: Type -> Type) where Source #

The Monad class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's do expressions provide a convenient syntax for writing monadic expressions.

Instances of Monad should satisfy the following:

Left identity: return a >>= k = k a
Right identity: m >>= return = m
Associativity: m >>= (\x -> k x >>= h) = (m >>= k) >>= h

Furthermore, the Monad and Applicative operations should relate as follows:

```
pure = return
```

m1 <*> m2 = m1 >>= (\x1 -> m2 >>= (\x2 -> return (x1 x2)))

The above laws imply:

```
fmap f xs  =  xs >>= return . f
```
```
(>>) = (*>)
```

and that pure and (<*>) satisfy the applicative functor laws.

The instances of Monad for List, Maybe and IO defined in the Prelude satisfy these laws.

Minimal complete definition

(>>=)

Methods

(>>=) :: m a -> (a -> m b) -> m b infixl 1 Source #

Sequentially compose two actions, passing any value produced by the first as an argument to the second.

'as >>= bs' can be understood as the do expression

do a <- as
   bs a

An alternative name for this function is 'bind', but some people may refer to it as 'flatMap', which results from it being equivialent to

\x f -> join (fmap f x) :: Monad m => m a -> (a -> m b) -> m b

which can be seen as mapping a value with Monad m => m a -> m (m b) and then 'flattening' m (m b) to m b using join.

(>>) :: m a -> m b -> m b infixl 1 Source #

Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.

'as >> bs' can be understood as the do expression

do as
   bs

or in terms of (>>=) as

as >>= const bs

return :: a -> m a Source #

Inject a value into the monadic type. This function should not be different from its default implementation as pure. The justification for the existence of this function is merely historic.

Instances

Instances details

Monad NonEmpty Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b Source # (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b Source # return :: a -> NonEmpty a Source #
Monad STM Source #	Since: base-4.3.0.0
Instance details Defined in GHC.Internal.Conc.Sync Methods (>>=) :: STM a -> (a -> STM b) -> STM b Source # (>>) :: STM a -> STM b -> STM b Source # return :: a -> STM a Source #
Monad Identity Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Functor.Identity Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b Source # (>>) :: Identity a -> Identity b -> Identity b Source # return :: a -> Identity a Source #
Monad First Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Monoid Methods (>>=) :: First a -> (a -> First b) -> First b Source # (>>) :: First a -> First b -> First b Source # return :: a -> First a Source #
Monad Last Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Monoid Methods (>>=) :: Last a -> (a -> Last b) -> Last b Source # (>>) :: Last a -> Last b -> Last b Source # return :: a -> Last a Source #
Monad Down Source #	Since: base-4.11.0.0
Instance details Defined in GHC.Internal.Data.Ord Methods (>>=) :: Down a -> (a -> Down b) -> Down b Source # (>>) :: Down a -> Down b -> Down b Source # return :: a -> Down a Source #
Monad Dual Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods (>>=) :: Dual a -> (a -> Dual b) -> Dual b Source # (>>) :: Dual a -> Dual b -> Dual b Source # return :: a -> Dual a Source #
Monad Product Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods (>>=) :: Product a -> (a -> Product b) -> Product b Source # (>>) :: Product a -> Product b -> Product b Source # return :: a -> Product a Source #
Monad Sum Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods (>>=) :: Sum a -> (a -> Sum b) -> Sum b Source # (>>) :: Sum a -> Sum b -> Sum b Source # return :: a -> Sum a Source #
Monad NoIO Source #	Since: base-4.4.0.0
Instance details Defined in GHC.Internal.GHCi Methods (>>=) :: NoIO a -> (a -> NoIO b) -> NoIO b Source # (>>) :: NoIO a -> NoIO b -> NoIO b Source # return :: a -> NoIO a Source #
Monad Par1 Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods (>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b Source # (>>) :: Par1 a -> Par1 b -> Par1 b Source # return :: a -> Par1 a Source #
Monad ReadP Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods (>>=) :: ReadP a -> (a -> ReadP b) -> ReadP b Source # (>>) :: ReadP a -> ReadP b -> ReadP b Source # return :: a -> ReadP a Source #
Monad ReadPrec Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadPrec Methods (>>=) :: ReadPrec a -> (a -> ReadPrec b) -> ReadPrec b Source # (>>) :: ReadPrec a -> ReadPrec b -> ReadPrec b Source # return :: a -> ReadPrec a Source #
Monad IO Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods (>>=) :: IO a -> (a -> IO b) -> IO b Source # (>>) :: IO a -> IO b -> IO b Source # return :: a -> IO a Source #
Monad Maybe Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b Source # (>>) :: Maybe a -> Maybe b -> Maybe b Source # return :: a -> Maybe a Source #
Monad Solo Source #	Since: base-4.15
Instance details Defined in GHC.Internal.Base Methods (>>=) :: Solo a -> (a -> Solo b) -> Solo b Source # (>>) :: Solo a -> Solo b -> Solo b Source # return :: a -> Solo a Source #
Monad [] Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods (>>=) :: [a] -> (a -> [b]) -> [b] Source # (>>) :: [a] -> [b] -> [b] Source # return :: a -> [a] Source #
ArrowApply a => Monad (ArrowMonad a) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Control.Arrow Methods (>>=) :: ArrowMonad a a0 -> (a0 -> ArrowMonad a b) -> ArrowMonad a b Source # (>>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b Source # return :: a0 -> ArrowMonad a a0 Source #
Monad (ST s) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Control.Monad.ST.Lazy.Imp Methods (>>=) :: ST s a -> (a -> ST s b) -> ST s b Source # (>>) :: ST s a -> ST s b -> ST s b Source # return :: a -> ST s a Source #
Monad (Either e) Source #	Since: base-4.4.0.0
Instance details Defined in GHC.Internal.Data.Either Methods (>>=) :: Either e a -> (a -> Either e b) -> Either e b Source # (>>) :: Either e a -> Either e b -> Either e b Source # return :: a -> Either e a Source #
Monad (Proxy :: Type -> Type) Source #	Since: base-4.7.0.0
Instance details Defined in GHC.Internal.Data.Proxy Methods (>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b Source # (>>) :: Proxy a -> Proxy b -> Proxy b Source # return :: a -> Proxy a Source #
Monad (U1 :: Type -> Type) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods (>>=) :: U1 a -> (a -> U1 b) -> U1 b Source # (>>) :: U1 a -> U1 b -> U1 b Source # return :: a -> U1 a Source #
Monad (ST s) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.ST Methods (>>=) :: ST s a -> (a -> ST s b) -> ST s b Source # (>>) :: ST s a -> ST s b -> ST s b Source # return :: a -> ST s a Source #
Monoid a => Monad ((,) a) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods (>>=) :: (a, a0) -> (a0 -> (a, b)) -> (a, b) Source # (>>) :: (a, a0) -> (a, b) -> (a, b) Source # return :: a0 -> (a, a0) Source #
Monad m => Monad (Kleisli m a) Source #	Since: base-4.14.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods (>>=) :: Kleisli m a a0 -> (a0 -> Kleisli m a b) -> Kleisli m a b Source # (>>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b Source # return :: a0 -> Kleisli m a a0 Source #
Monad m => Monad (StateT s m) Source #	Since: base-4.18.0.0
Instance details Defined in GHC.Internal.Data.Functor.Utils Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b Source # (>>) :: StateT s m a -> StateT s m b -> StateT s m b Source # return :: a -> StateT s m a Source #
Monad f => Monad (Ap f) Source #	Since: base-4.12.0.0
Instance details Defined in GHC.Internal.Data.Monoid Methods (>>=) :: Ap f a -> (a -> Ap f b) -> Ap f b Source # (>>) :: Ap f a -> Ap f b -> Ap f b Source # return :: a -> Ap f a Source #
Monad f => Monad (Alt f) Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods (>>=) :: Alt f a -> (a -> Alt f b) -> Alt f b Source # (>>) :: Alt f a -> Alt f b -> Alt f b Source # return :: a -> Alt f a Source #
Monad f => Monad (Rec1 f) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods (>>=) :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b Source # (>>) :: Rec1 f a -> Rec1 f b -> Rec1 f b Source # return :: a -> Rec1 f a Source #
(Monoid a, Monoid b) => Monad ((,,) a b) Source #	Since: base-4.14.0.0
Instance details Defined in GHC.Internal.Base Methods (>>=) :: (a, b, a0) -> (a0 -> (a, b, b0)) -> (a, b, b0) Source # (>>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0) Source # return :: a0 -> (a, b, a0) Source #
(Monad f, Monad g) => Monad (f :*: g) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods (>>=) :: (f :: g) a -> (a -> (f :: g) b) -> (f :: g) b Source # (>>) :: (f :: g) a -> (f :: g) b -> (f :: g) b Source # return :: a -> (f :*: g) a Source #
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) Source #	Since: base-4.14.0.0
Instance details Defined in GHC.Internal.Base Methods (>>=) :: (a, b, c, a0) -> (a0 -> (a, b, c, b0)) -> (a, b, c, b0) Source # (>>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) Source # return :: a0 -> (a, b, c, a0) Source #
Monad ((->) r) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods (>>=) :: (r -> a) -> (a -> r -> b) -> r -> b Source # (>>) :: (r -> a) -> (r -> b) -> r -> b Source # return :: a -> r -> a Source #
Monad f => Monad (M1 i c f) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods (>>=) :: M1 i c f a -> (a -> M1 i c f b) -> M1 i c f b Source # (>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b Source # return :: a -> M1 i c f a Source #

(.) :: (b -> c) -> (a -> b) -> a -> c infixr 9 Source #

Right to left function composition.

(f . g) x = f (g x)

f . id = f = id . f

Examples

Expand

>>> map ((*2) . length) [[], [0, 1, 2], [0]]
[0,6,2]

>>> foldr (.) id [(+1), (*3), (^3)] 2
25

>>> let (...) = (.).(.) in ((*2)...(+)) 5 10
30

id :: a -> a Source #

Identity function.

id x = x

This function might seem useless at first glance, but it can be very useful in a higher order context.

Examples

Expand

>>> length $ filter id [True, True, False, True]
3

>>> Just (Just 3) >>= id
Just 3

>>> foldr id 0 [(^3), (*5), (+2)]
1000

assert :: Bool -> a -> a Source #

If the first argument evaluates to True, then the result is the second argument. Otherwise an AssertionFailed exception is raised, containing a String with the source file and line number of the call to assert.

Assertions can normally be turned on or off with a compiler flag (for GHC, assertions are normally on unless optimisation is turned on with -O or the -fignore-asserts option is given). When assertions are turned off, the first argument to assert is ignored, and the second argument is returned as the result.

class Functor (f :: Type -> Type) where Source #

A type f is a Functor if it provides a function fmap which, given any types a and b lets you apply any function from (a -> b) to turn an f a into an f b, preserving the structure of f. Furthermore f needs to adhere to the following:

Identity: fmap id == id
Composition: fmap (f . g) == fmap f . fmap g

Note, that the second law follows from the free theorem of the type fmap and the first law, so you need only check that the former condition holds. See these articles by School of Haskell or David Luposchainsky for an explanation.

Minimal complete definition

fmap

Methods

fmap :: (a -> b) -> f a -> f b Source #

fmap is used to apply a function of type (a -> b) to a value of type f a, where f is a functor, to produce a value of type f b. Note that for any type constructor with more than one parameter (e.g., Either), only the last type parameter can be modified with fmap (e.g., b in `Either a b`).

Some type constructors with two parameters or more have a Bifunctor instance that allows both the last and the penultimate parameters to be mapped over.

Examples

Expand

Convert from a Maybe Int to a Maybe String using show:

>>> fmap show Nothing
Nothing
>>> fmap show (Just 3)
Just "3"

Convert from an Either Int Int to an Either Int String using show:

>>> fmap show (Left 17)
Left 17
>>> fmap show (Right 17)
Right "17"

Double each element of a list:

>>> fmap (*2) [1,2,3]
[2,4,6]

Apply even to the second element of a pair:

>>> fmap even (2,2)
(2,True)

It may seem surprising that the function is only applied to the last element of the tuple compared to the list example above which applies it to every element in the list. To understand, remember that tuples are type constructors with multiple type parameters: a tuple of 3 elements (a,b,c) can also be written (,,) a b c and its Functor instance is defined for Functor ((,,) a b) (i.e., only the third parameter is free to be mapped over with fmap).

It explains why fmap can be used with tuples containing values of different types as in the following example:

>>> fmap even ("hello", 1.0, 4)
("hello",1.0,True)

(<$) :: a -> f b -> f a infixl 4 Source #

Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.

Examples

Expand

Perform a computation with Maybe and replace the result with a constant value if it is Just:

>>> 'a' <$ Just 2
Just 'a'
>>> 'a' <$ Nothing
Nothing

Instances

Instances details

Functor NonEmpty Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods fmap :: (a -> b) -> NonEmpty a -> NonEmpty b Source # (<$) :: a -> NonEmpty b -> NonEmpty a Source #
Functor STM Source #	Since: base-4.3.0.0
Instance details Defined in GHC.Internal.Conc.Sync Methods fmap :: (a -> b) -> STM a -> STM b Source # (<$) :: a -> STM b -> STM a Source #
Functor Handler Source #	Since: base-4.6.0.0
Instance details Defined in GHC.Internal.Control.Exception Methods fmap :: (a -> b) -> Handler a -> Handler b Source # (<$) :: a -> Handler b -> Handler a Source #
Functor Identity Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Functor.Identity Methods fmap :: (a -> b) -> Identity a -> Identity b Source # (<$) :: a -> Identity b -> Identity a Source #
Functor First Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Monoid Methods fmap :: (a -> b) -> First a -> First b Source # (<$) :: a -> First b -> First a Source #
Functor Last Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Monoid Methods fmap :: (a -> b) -> Last a -> Last b Source # (<$) :: a -> Last b -> Last a Source #
Functor Down Source #	Since: base-4.11.0.0
Instance details Defined in GHC.Internal.Data.Ord Methods fmap :: (a -> b) -> Down a -> Down b Source # (<$) :: a -> Down b -> Down a Source #
Functor Dual Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods fmap :: (a -> b) -> Dual a -> Dual b Source # (<$) :: a -> Dual b -> Dual a Source #
Functor Product Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods fmap :: (a -> b) -> Product a -> Product b Source # (<$) :: a -> Product b -> Product a Source #
Functor Sum Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods fmap :: (a -> b) -> Sum a -> Sum b Source # (<$) :: a -> Sum b -> Sum a Source #
Functor ZipList Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Functor.ZipList Methods fmap :: (a -> b) -> ZipList a -> ZipList b Source # (<$) :: a -> ZipList b -> ZipList a Source #
Functor NoIO Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.GHCi Methods fmap :: (a -> b) -> NoIO a -> NoIO b Source # (<$) :: a -> NoIO b -> NoIO a Source #
Functor Par1 Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> Par1 a -> Par1 b Source # (<$) :: a -> Par1 b -> Par1 a Source #
Functor ReadP Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods fmap :: (a -> b) -> ReadP a -> ReadP b Source # (<$) :: a -> ReadP b -> ReadP a Source #
Functor ReadPrec Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadPrec Methods fmap :: (a -> b) -> ReadPrec a -> ReadPrec b Source # (<$) :: a -> ReadPrec b -> ReadPrec a Source #
Functor IO Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods fmap :: (a -> b) -> IO a -> IO b Source # (<$) :: a -> IO b -> IO a Source #
Functor Maybe Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods fmap :: (a -> b) -> Maybe a -> Maybe b Source # (<$) :: a -> Maybe b -> Maybe a Source #
Functor Solo Source #	Since: base-4.15
Instance details Defined in GHC.Internal.Base Methods fmap :: (a -> b) -> Solo a -> Solo b Source # (<$) :: a -> Solo b -> Solo a Source #
Functor [] Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods fmap :: (a -> b) -> [a] -> [b] Source # (<$) :: a -> [b] -> [a] Source #
Functor (Array i) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Arr Methods fmap :: (a -> b) -> Array i a -> Array i b Source # (<$) :: a -> Array i b -> Array i a Source #
Arrow a => Functor (ArrowMonad a) Source #	Since: base-4.6.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b Source # (<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0 Source #
Functor (ST s) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Control.Monad.ST.Lazy.Imp Methods fmap :: (a -> b) -> ST s a -> ST s b Source # (<$) :: a -> ST s b -> ST s a Source #
Functor (Either a) Source #	Since: base-3.0
Instance details Defined in GHC.Internal.Data.Either Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b Source # (<$) :: a0 -> Either a b -> Either a a0 Source #
Functor (StateL s) Source #	Since: base-4.0
Instance details Defined in GHC.Internal.Data.Functor.Utils Methods fmap :: (a -> b) -> StateL s a -> StateL s b Source # (<$) :: a -> StateL s b -> StateL s a Source #
Functor (StateR s) Source #	Since: base-4.0
Instance details Defined in GHC.Internal.Data.Functor.Utils Methods fmap :: (a -> b) -> StateR s a -> StateR s b Source # (<$) :: a -> StateR s b -> StateR s a Source #
Functor (Proxy :: Type -> Type) Source #	Since: base-4.7.0.0
Instance details Defined in GHC.Internal.Data.Proxy Methods fmap :: (a -> b) -> Proxy a -> Proxy b Source # (<$) :: a -> Proxy b -> Proxy a Source #
Functor (U1 :: Type -> Type) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> U1 a -> U1 b Source # (<$) :: a -> U1 b -> U1 a Source #
Functor (V1 :: Type -> Type) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> V1 a -> V1 b Source # (<$) :: a -> V1 b -> V1 a Source #
Functor (ST s) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.ST Methods fmap :: (a -> b) -> ST s a -> ST s b Source # (<$) :: a -> ST s b -> ST s a Source #
Functor ((,) a) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods fmap :: (a0 -> b) -> (a, a0) -> (a, b) Source # (<$) :: a0 -> (a, b) -> (a, a0) Source #
Functor m => Functor (Kleisli m a) Source #	Since: base-4.14.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods fmap :: (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b Source # (<$) :: a0 -> Kleisli m a b -> Kleisli m a a0 Source #
Functor (Const m :: Type -> Type) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Data.Functor.Const Methods fmap :: (a -> b) -> Const m a -> Const m b Source # (<$) :: a -> Const m b -> Const m a Source #
Monad m => Functor (StateT s m) Source #	Since: base-4.18.0.0
Instance details Defined in GHC.Internal.Data.Functor.Utils Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b Source # (<$) :: a -> StateT s m b -> StateT s m a Source #
Functor f => Functor (Ap f) Source #	Since: base-4.12.0.0
Instance details Defined in GHC.Internal.Data.Monoid Methods fmap :: (a -> b) -> Ap f a -> Ap f b Source # (<$) :: a -> Ap f b -> Ap f a Source #
Functor f => Functor (Alt f) Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods fmap :: (a -> b) -> Alt f a -> Alt f b Source # (<$) :: a -> Alt f b -> Alt f a Source #
(Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f) Source #	Since: base-4.17.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> Generically1 f a -> Generically1 f b Source # (<$) :: a -> Generically1 f b -> Generically1 f a Source #
Functor f => Functor (Rec1 f) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> Rec1 f a -> Rec1 f b Source # (<$) :: a -> Rec1 f b -> Rec1 f a Source #
Functor (URec (Ptr ()) :: Type -> Type) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b Source # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a Source #
Functor (URec Char :: Type -> Type) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> URec Char a -> URec Char b Source # (<$) :: a -> URec Char b -> URec Char a Source #
Functor (URec Double :: Type -> Type) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> URec Double a -> URec Double b Source # (<$) :: a -> URec Double b -> URec Double a Source #
Functor (URec Float :: Type -> Type) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> URec Float a -> URec Float b Source # (<$) :: a -> URec Float b -> URec Float a Source #
Functor (URec Int :: Type -> Type) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> URec Int a -> URec Int b Source # (<$) :: a -> URec Int b -> URec Int a Source #
Functor (URec Word :: Type -> Type) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> URec Word a -> URec Word b Source # (<$) :: a -> URec Word b -> URec Word a Source #
Functor ((,,) a b) Source #	Since: base-4.14.0.0
Instance details Defined in GHC.Internal.Base Methods fmap :: (a0 -> b0) -> (a, b, a0) -> (a, b, b0) Source # (<$) :: a0 -> (a, b, b0) -> (a, b, a0) Source #
(Functor f, Functor g) => Functor (f :*: g) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> (f :: g) a -> (f :: g) b Source # (<$) :: a -> (f :: g) b -> (f :: g) a Source #
(Functor f, Functor g) => Functor (f :+: g) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b Source # (<$) :: a -> (f :+: g) b -> (f :+: g) a Source #
Functor (K1 i c :: Type -> Type) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> K1 i c a -> K1 i c b Source # (<$) :: a -> K1 i c b -> K1 i c a Source #
Functor ((,,,) a b c) Source #	Since: base-4.14.0.0
Instance details Defined in GHC.Internal.Base Methods fmap :: (a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) Source # (<$) :: a0 -> (a, b, c, b0) -> (a, b, c, a0) Source #
Functor ((->) r) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods fmap :: (a -> b) -> (r -> a) -> r -> b Source # (<$) :: a -> (r -> b) -> r -> a Source #
(Functor f, Functor g) => Functor (f :.: g) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b Source # (<$) :: a -> (f :.: g) b -> (f :.: g) a Source #
Functor f => Functor (M1 i c f) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> M1 i c f a -> M1 i c f b Source # (<$) :: a -> M1 i c f b -> M1 i c f a Source #
Functor ((,,,,) a b c d) Source #	Since: base-4.18.0.0
Instance details Defined in GHC.Internal.Base Methods fmap :: (a0 -> b0) -> (a, b, c, d, a0) -> (a, b, c, d, b0) Source # (<$) :: a0 -> (a, b, c, d, b0) -> (a, b, c, d, a0) Source #
Functor ((,,,,,) a b c d e) Source #	Since: base-4.18.0.0
Instance details Defined in GHC.Internal.Base Methods fmap :: (a0 -> b0) -> (a, b, c, d, e, a0) -> (a, b, c, d, e, b0) Source # (<$) :: a0 -> (a, b, c, d, e, b0) -> (a, b, c, d, e, a0) Source #
Functor ((,,,,,,) a b c d e f) Source #	Since: base-4.18.0.0
Instance details Defined in GHC.Internal.Base Methods fmap :: (a0 -> b0) -> (a, b, c, d, e, f, a0) -> (a, b, c, d, e, f, b0) Source # (<$) :: a0 -> (a, b, c, d, e, f, b0) -> (a, b, c, d, e, f, a0) Source #

class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where Source #

Monads that also support choice and failure.

Minimal complete definition

Nothing

Methods

mzero :: m a Source #

The identity of mplus. It should also satisfy the equations

mzero >>= f  =  mzero
v >> mzero   =  mzero

The default definition is

mzero = empty

mplus :: m a -> m a -> m a Source #

An associative operation. The default definition is

mplus = (<|>)

Instances

Instances details

MonadPlus STM Source #	Takes the first non-`retry`ing `STM` action. Since: base-4.3.0.0
Instance details Defined in GHC.Internal.Conc.Sync Methods mzero :: STM a Source # mplus :: STM a -> STM a -> STM a Source #
MonadPlus ReadP Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods mzero :: ReadP a Source # mplus :: ReadP a -> ReadP a -> ReadP a Source #
MonadPlus ReadPrec Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadPrec Methods mzero :: ReadPrec a Source # mplus :: ReadPrec a -> ReadPrec a -> ReadPrec a Source #
MonadPlus IO Source #	Takes the first non-throwing `IO` action's result. `mzero` throws an exception. Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods mzero :: IO a Source # mplus :: IO a -> IO a -> IO a Source #
MonadPlus Maybe Source #	Picks the leftmost `Just` value, or, alternatively, `Nothing`. Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods mzero :: Maybe a Source # mplus :: Maybe a -> Maybe a -> Maybe a Source #
MonadPlus [] Source #	Combines lists by concatenation, starting from the empty list. Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods mzero :: [a] Source # mplus :: [a] -> [a] -> [a] Source #
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a) Source #	Since: base-4.6.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods mzero :: ArrowMonad a a0 Source # mplus :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 Source #
MonadPlus (Proxy :: Type -> Type) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Proxy Methods mzero :: Proxy a Source # mplus :: Proxy a -> Proxy a -> Proxy a Source #
MonadPlus (U1 :: Type -> Type) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods mzero :: U1 a Source # mplus :: U1 a -> U1 a -> U1 a Source #
MonadPlus m => MonadPlus (Kleisli m a) Source #	Since: base-4.14.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods mzero :: Kleisli m a a0 Source # mplus :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 Source #
MonadPlus f => MonadPlus (Ap f) Source #	Since: base-4.12.0.0
Instance details Defined in GHC.Internal.Data.Monoid Methods mzero :: Ap f a Source # mplus :: Ap f a -> Ap f a -> Ap f a Source #
MonadPlus f => MonadPlus (Alt f) Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mzero :: Alt f a Source # mplus :: Alt f a -> Alt f a -> Alt f a Source #
MonadPlus f => MonadPlus (Rec1 f) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods mzero :: Rec1 f a Source # mplus :: Rec1 f a -> Rec1 f a -> Rec1 f a Source #
(MonadPlus f, MonadPlus g) => MonadPlus (f :*: g) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods mzero :: (f :: g) a Source # mplus :: (f :: g) a -> (f :: g) a -> (f :: g) a Source #
MonadPlus f => MonadPlus (M1 i c f) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods mzero :: M1 i c f a Source # mplus :: M1 i c f a -> M1 i c f a -> M1 i c f a Source #

mapM :: Monad m => (a -> m b) -> [a] -> m [b] Source #

mapM f is equivalent to sequence . map f.

sequence :: Monad m => [m a] -> m [a] Source #

Evaluate each action in the sequence from left to right, and collect the results.

(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 Source #

Same as >>=, but with the arguments interchanged.

as >>= f == f =<< as

join :: Monad m => m (m a) -> m a Source #

The join function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.

'join bss' can be understood as the do expression

do bs <- bss
   bs

Examples

Expand

>>> join [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
[1,2,3,4,5,6,7,8,9]

>>> join (Just (Just 3))
Just 3

A common use of join is to run an IO computation returned from an STM transaction, since STM transactions can't perform IO directly. Recall that

atomically :: STM a -> IO a

is used to run STM transactions atomically. So, by specializing the types of atomically and join to

atomically :: STM (IO b) -> IO (IO b)
join       :: IO (IO b)  -> IO b

we can compose them as

join . atomically :: STM (IO b) -> IO b

to run an STM transaction and the IO action it returns.

when :: Applicative f => Bool -> f () -> f () Source #

Conditional execution of Applicative expressions. For example,

Examples

Expand

when debug (putStrLn "Debugging")

will output the string Debugging if the Boolean value debug is True, and otherwise do nothing.

>>> putStr "pi:" >> when False (print 3.14159)
pi:

liftM :: Monad m => (a1 -> r) -> m a1 -> m r Source #

Promote a function to a monad. This is equivalent to fmap but specialised to Monads.

liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r Source #

Promote a function to a monad, scanning the monadic arguments from left to right.

Examples

Expand

>>> liftM2 (+) [0,1] [0,2]
[0,2,1,3]

>>> liftM2 (+) (Just 1) Nothing
Nothing

>>> liftM2 (+) (+ 3) (* 2) 5
18

liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r Source #

Promote a function to a monad, scanning the monadic arguments from left to right (cf. liftM2).

liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r Source #

Promote a function to a monad, scanning the monadic arguments from left to right (cf. liftM2).

liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r Source #

Promote a function to a monad, scanning the monadic arguments from left to right (cf. liftM2).

ap :: Monad m => m (a -> b) -> m a -> m b Source #

In many situations, the liftM operations can be replaced by uses of ap, which promotes function application.

return f `ap` x1 `ap` ... `ap` xn

is equivalent to

liftM<n> f x1 x2 ... xn

Examples

Expand

>>> pure (\x y z -> x + y * z) `ap` Just 1 `ap` Just 5 `ap` Just 10
Just 51

failIO :: String -> IO a Source #

class Semigroup a => Monoid a where Source #

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following:

Right identity: x <> mempty = x
Left identity: mempty <> x = x
Associativity: x <> (y <> z) = (x <> y) <> z (Semigroup law)
Concatenation: mconcat = foldr (<>) mempty

You can alternatively define mconcat instead of mempty, in which case the laws are:

Unit: mconcat (pure x) = x
Multiplication: mconcat (join xss) = mconcat (fmap mconcat xss)
Subclass: mconcat (toList xs) = sconcat xs

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of Monoid, e.g. Sum and Product.

NOTE: Semigroup is a superclass of Monoid since base-4.11.0.0.

Minimal complete definition

mempty | mconcat

Methods

mempty :: a Source #

Identity of mappend

Examples

Expand

>>> "Hello world" <> mempty
"Hello world"

>>> mempty <> [1, 2, 3]
[1,2,3]

mappend :: a -> a -> a Source #

An associative operation

NOTE: This method is redundant and has the default implementation mappend = (<>) since base-4.11.0.0. Should it be implemented manually, since mappend is a synonym for (<>), it is expected that the two functions are defined the same way. In a future GHC release mappend will be removed from Monoid.

mconcat :: [a] -> a Source #

Fold a list using the monoid.

For most types, the default definition for mconcat will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

>>> mconcat ["Hello", " ", "Haskell", "!"]
"Hello Haskell!"

Instances

Instances details

Monoid All Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mempty :: All Source # mappend :: All -> All -> All Source # mconcat :: [All] -> All Source #
Monoid Any Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mempty :: Any Source # mappend :: Any -> Any -> Any Source # mconcat :: [Any] -> Any Source #
Monoid Event Source #	Since: base-4.4.0.0
Instance details Defined in GHC.Internal.Event.Internal.Types Methods mempty :: Event Source # mappend :: Event -> Event -> Event Source # mconcat :: [Event] -> Event Source #
Monoid Lifetime Source #	`mappend` takes the longer of two lifetimes. Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Event.Internal.Types Methods mempty :: Lifetime Source # mappend :: Lifetime -> Lifetime -> Lifetime Source # mconcat :: [Lifetime] -> Lifetime Source #
Monoid ExceptionContext Source #
Instance details Defined in GHC.Internal.Exception.Context Methods mempty :: ExceptionContext Source # mappend :: ExceptionContext -> ExceptionContext -> ExceptionContext Source # mconcat :: [ExceptionContext] -> ExceptionContext Source #
Monoid Ordering Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods mempty :: Ordering Source # mappend :: Ordering -> Ordering -> Ordering Source # mconcat :: [Ordering] -> Ordering Source #
Monoid () Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods mempty :: () Source # mappend :: () -> () -> () Source # mconcat :: [()] -> () Source #
Monoid a => Monoid (STM a) Source #	Since: base-4.17.0.0
Instance details Defined in GHC.Internal.Conc.Sync Methods mempty :: STM a Source # mappend :: STM a -> STM a -> STM a Source # mconcat :: [STM a] -> STM a Source #
FiniteBits a => Monoid (And a) Source #	This constraint is arguably too strong. However, as some types (such as `Natural`) have undefined `complement`, this is the only safe choice. Since: base-4.16
Instance details Defined in GHC.Internal.Data.Bits Methods mempty :: And a Source # mappend :: And a -> And a -> And a Source # mconcat :: [And a] -> And a Source #
FiniteBits a => Monoid (Iff a) Source #	This constraint is arguably too strong. However, as some types (such as `Natural`) have undefined `complement`, this is the only safe choice. Since: base-4.16
Instance details Defined in GHC.Internal.Data.Bits Methods mempty :: Iff a Source # mappend :: Iff a -> Iff a -> Iff a Source # mconcat :: [Iff a] -> Iff a Source #
Bits a => Monoid (Ior a) Source #	Since: base-4.16
Instance details Defined in GHC.Internal.Data.Bits Methods mempty :: Ior a Source # mappend :: Ior a -> Ior a -> Ior a Source # mconcat :: [Ior a] -> Ior a Source #
Bits a => Monoid (Xor a) Source #	Since: base-4.16
Instance details Defined in GHC.Internal.Data.Bits Methods mempty :: Xor a Source # mappend :: Xor a -> Xor a -> Xor a Source # mconcat :: [Xor a] -> Xor a Source #
Monoid a => Monoid (Identity a) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Identity Methods mempty :: Identity a Source # mappend :: Identity a -> Identity a -> Identity a Source # mconcat :: [Identity a] -> Identity a Source #
Ord a => Monoid (Max a) Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Functor.Utils Methods mempty :: Max a Source # mappend :: Max a -> Max a -> Max a Source # mconcat :: [Max a] -> Max a Source #
Ord a => Monoid (Min a) Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Functor.Utils Methods mempty :: Min a Source # mappend :: Min a -> Min a -> Min a Source # mconcat :: [Min a] -> Min a Source #
Monoid (First a) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Data.Monoid Methods mempty :: First a Source # mappend :: First a -> First a -> First a Source # mconcat :: [First a] -> First a Source #
Monoid (Last a) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Data.Monoid Methods mempty :: Last a Source # mappend :: Last a -> Last a -> Last a Source # mconcat :: [Last a] -> Last a Source #
Monoid a => Monoid (Down a) Source #	Since: base-4.11.0.0
Instance details Defined in GHC.Internal.Data.Ord Methods mempty :: Down a Source # mappend :: Down a -> Down a -> Down a Source # mconcat :: [Down a] -> Down a Source #
Monoid a => Monoid (Dual a) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mempty :: Dual a Source # mappend :: Dual a -> Dual a -> Dual a Source # mconcat :: [Dual a] -> Dual a Source #
Monoid (Endo a) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mempty :: Endo a Source # mappend :: Endo a -> Endo a -> Endo a Source # mconcat :: [Endo a] -> Endo a Source #
Num a => Monoid (Product a) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mempty :: Product a Source # mappend :: Product a -> Product a -> Product a Source # mconcat :: [Product a] -> Product a Source #
Num a => Monoid (Sum a) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mempty :: Sum a Source # mappend :: Sum a -> Sum a -> Sum a Source # mconcat :: [Sum a] -> Sum a Source #
(Generic a, Monoid (Rep a ())) => Monoid (Generically a) Source #	Since: base-4.17.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: Generically a Source # mappend :: Generically a -> Generically a -> Generically a Source # mconcat :: [Generically a] -> Generically a Source #
Monoid p => Monoid (Par1 p) Source #	Since: base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: Par1 p Source # mappend :: Par1 p -> Par1 p -> Par1 p Source # mconcat :: [Par1 p] -> Par1 p Source #
Monoid a => Monoid (IO a) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods mempty :: IO a Source # mappend :: IO a -> IO a -> IO a Source # mconcat :: [IO a] -> IO a Source #
Semigroup a => Monoid (Maybe a) Source #	Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `ee = e` and `es = s = se` for all `s ∈ S`." Since 4.11.0: constraint on inner `a` value generalised from `Monoid` to `Semigroup`. Since: base-2.1*
Instance details Defined in GHC.Internal.Base Methods mempty :: Maybe a Source # mappend :: Maybe a -> Maybe a -> Maybe a Source # mconcat :: [Maybe a] -> Maybe a Source #
Monoid a => Monoid (Solo a) Source #	Since: base-4.15
Instance details Defined in GHC.Internal.Base Methods mempty :: Solo a Source # mappend :: Solo a -> Solo a -> Solo a Source # mconcat :: [Solo a] -> Solo a Source #
Monoid [a] Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods mempty :: [a] Source # mappend :: [a] -> [a] -> [a] Source # mconcat :: [[a]] -> [a] Source #
Monoid (Proxy s) Source #	Since: base-4.7.0.0
Instance details Defined in GHC.Internal.Data.Proxy Methods mempty :: Proxy s Source # mappend :: Proxy s -> Proxy s -> Proxy s Source # mconcat :: [Proxy s] -> Proxy s Source #
Monoid (U1 p) Source #	Since: base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: U1 p Source # mappend :: U1 p -> U1 p -> U1 p Source # mconcat :: [U1 p] -> U1 p Source #
Monoid a => Monoid (ST s a) Source #	Since: base-4.11.0.0
Instance details Defined in GHC.Internal.ST Methods mempty :: ST s a Source # mappend :: ST s a -> ST s a -> ST s a Source # mconcat :: [ST s a] -> ST s a Source #
(Monoid a, Monoid b) => Monoid (a, b) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods mempty :: (a, b) Source # mappend :: (a, b) -> (a, b) -> (a, b) Source # mconcat :: [(a, b)] -> (a, b) Source #
Monoid b => Monoid (a -> b) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods mempty :: a -> b Source # mappend :: (a -> b) -> (a -> b) -> a -> b Source # mconcat :: [a -> b] -> a -> b Source #
Monoid a => Monoid (Const a b) Source #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods mempty :: Const a b Source # mappend :: Const a b -> Const a b -> Const a b Source # mconcat :: [Const a b] -> Const a b Source #
(Applicative f, Monoid a) => Monoid (Ap f a) Source #	Since: base-4.12.0.0
Instance details Defined in GHC.Internal.Data.Monoid Methods mempty :: Ap f a Source # mappend :: Ap f a -> Ap f a -> Ap f a Source # mconcat :: [Ap f a] -> Ap f a Source #
Alternative f => Monoid (Alt f a) Source #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mempty :: Alt f a Source # mappend :: Alt f a -> Alt f a -> Alt f a Source # mconcat :: [Alt f a] -> Alt f a Source #
Monoid (f p) => Monoid (Rec1 f p) Source #	Since: base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: Rec1 f p Source # mappend :: Rec1 f p -> Rec1 f p -> Rec1 f p Source # mconcat :: [Rec1 f p] -> Rec1 f p Source #
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods mempty :: (a, b, c) Source # mappend :: (a, b, c) -> (a, b, c) -> (a, b, c) Source # mconcat :: [(a, b, c)] -> (a, b, c) Source #
(Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) Source #	Since: base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: (f :: g) p Source # mappend :: (f :: g) p -> (f :: g) p -> (f :: g) p Source # mconcat :: [(f :: g) p] -> (f :: g) p Source #
Monoid c => Monoid (K1 i c p) Source #	Since: base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: K1 i c p Source # mappend :: K1 i c p -> K1 i c p -> K1 i c p Source # mconcat :: [K1 i c p] -> K1 i c p Source #
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods mempty :: (a, b, c, d) Source # mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) Source # mconcat :: [(a, b, c, d)] -> (a, b, c, d) Source #
Monoid (f (g p)) => Monoid ((f :.: g) p) Source #	Since: base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: (f :.: g) p Source # mappend :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p Source # mconcat :: [(f :.: g) p] -> (f :.: g) p Source #
Monoid (f p) => Monoid (M1 i c f p) Source #	Since: base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods mempty :: M1 i c f p Source # mappend :: M1 i c f p -> M1 i c f p -> M1 i c f p Source # mconcat :: [M1 i c f p] -> M1 i c f p Source #
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) Source #	Since: base-2.1
Instance details Defined in GHC.Internal.Base Methods mempty :: (a, b, c, d, e) Source # mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) Source # mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e) Source #

data NonEmpty a Source #

Non-empty (and non-strict) list type.

Since: base-4.9.0.0

Constructors

a :| [a] infixr 5

Instances

Instances details

Applicative NonEmpty Source #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Base

Methods

pure :: a -> NonEmpty a Source #

(<*>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b Source #

liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c Source #

(*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b Source #

(<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a Source #

Functor NonEmpty Source #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Base

Methods

fmap :: (a -> b) -> NonEmpty a -> NonEmpty b Source #

(<$) :: a -> NonEmpty b -> NonEmpty a Source #

Monad NonEmpty Source #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Base

Methods

(>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b Source #

(>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b Source #

return :: a -> NonEmpty a Source #

MonadFix NonEmpty Source #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Control.Monad.Fix

Methods

mfix :: (a -> NonEmpty a) -> NonEmpty a Source #

Foldable NonEmpty Source #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Data.Foldable

Methods

fold :: Monoid m => NonEmpty m -> m Source #

foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m Source #

foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m Source #

foldr :: (a -> b -> b) -> b -> NonEmpty a -> b Source #

foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b Source #

foldl :: (b -> a -> b) -> b -> NonEmpty a -> b Source #

foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b Source #

foldr1 :: (a -> a -> a) -> NonEmpty a -> a Source #

foldl1 :: (a -> a -> a) -> NonEmpty a -> a Source #

toList :: NonEmpty a -> [a] Source #

null :: NonEmpty a -> Bool Source #

length :: NonEmpty a -> Int Source #

elem :: Eq a => a -> NonEmpty a -> Bool Source #

maximum :: Ord a => NonEmpty a -> a Source #

minimum :: Ord a => NonEmpty a -> a Source #

sum :: Num a => NonEmpty a -> a Source #

product :: Num a => NonEmpty a -> a Source #

Traversable NonEmpty Source #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) Source #

sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a) Source #

mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b) Source #

sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a) Source #

Generic1 NonEmpty Source #

Instance details

Defined in GHC.Internal.Generics

Associated Types

type Rep1 NonEmpty	Since: base-4.6.0.0
Instance details Defined in GHC.Internal.Generics type Rep1 NonEmpty = D1 ('MetaData "NonEmpty" "GHC.Internal.Base" "ghc-internal" 'False) (C1 ('MetaCons ":\|" ('InfixI 'RightAssociative 5) '