| Copyright | (c) The University of Glasgow 2002 |
|---|---|
| License | see libraries/base/LICENSE |
| Maintainer | cvs-ghc@haskell.org |
| Stability | internal |
| Portability | non-portable (GHC Extensions) |
| Safe Haskell | Unsafe |
| Language | Haskell2010 |
GHC.Exts
Contents
RealWorld state transformersDescription
GHC Extensions: this is the Approved Way to get at GHC-specific extensions.
Note: no other base module should import this module.
A fixed-precision integer type with at least the range[-2^29 .. 2^29-1]. The exact range for a given implementation can be determined by usingminBound andmaxBound from theBounded class.
| BoundedIntSource# | Since: 2.1 |
| EnumIntSource# | Since: 2.1 |
| EqInt | |
| IntegralIntSource# | Since: 2.0.1 |
| DataIntSource# | Since: 4.0.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Int -> cIntSource# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> cIntSource# toConstr ::Int ->ConstrSource# dataTypeOf ::Int ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (cInt)Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (cInt)Source# gmapT :: (forall b.Data b => b -> b) ->Int ->IntSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Int -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Int -> rSource# gmapQ :: (forall d.Data d => d -> u) ->Int -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->Int -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->Int -> mIntSource# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Int -> mIntSource# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Int -> mIntSource# | |
| NumIntSource# | Since: 2.1 |
| OrdInt | |
| ReadIntSource# | Since: 2.1 |
| RealIntSource# | Since: 2.0.1 |
| ShowIntSource# | Since: 2.1 |
| IxIntSource# | Since: 2.1 |
| FiniteBitsIntSource# | Since: 4.6.0.0 |
| BitsIntSource# | Since: 2.1 |
Instance detailsDefined inData.Bits Methods (.&.) ::Int ->Int ->IntSource# (.|.) ::Int ->Int ->IntSource# complement ::Int ->IntSource# shift ::Int ->Int ->IntSource# rotate ::Int ->Int ->IntSource# setBit ::Int ->Int ->IntSource# clearBit ::Int ->Int ->IntSource# complementBit ::Int ->Int ->IntSource# testBit ::Int ->Int ->BoolSource# bitSizeMaybe ::Int ->MaybeIntSource# shiftL ::Int ->Int ->IntSource# unsafeShiftL ::Int ->Int ->IntSource# shiftR ::Int ->Int ->IntSource# unsafeShiftR ::Int ->Int ->IntSource# rotateL ::Int ->Int ->IntSource# | |
| StorableIntSource# | Since: 2.1 |
Instance detailsDefined inForeign.Storable | |
| PrintfArgIntSource# | Since: 2.1 |
Instance detailsDefined inText.Printf | |
| Generic1 (URecInt :: k ->Type)Source# | |
| Functor (URecInt ::Type ->Type)Source# | Since: 4.9.0.0 |
| Foldable (URecInt ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>URecInt m -> mSource# foldMap ::Monoid m => (a -> m) ->URecInt a -> mSource# foldr :: (a -> b -> b) -> b ->URecInt a -> bSource# foldr' :: (a -> b -> b) -> b ->URecInt a -> bSource# foldl :: (b -> a -> b) -> b ->URecInt a -> bSource# foldl' :: (b -> a -> b) -> b ->URecInt a -> bSource# foldr1 :: (a -> a -> a) ->URecInt a -> aSource# foldl1 :: (a -> a -> a) ->URecInt a -> aSource# toList ::URecInt a -> [a]Source# null ::URecInt a ->BoolSource# length ::URecInt a ->IntSource# elem ::Eq a => a ->URecInt a ->BoolSource# maximum ::Ord a =>URecInt a -> aSource# minimum ::Ord a =>URecInt a -> aSource# | |
| Traversable (URecInt ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| Eq (URecInt p)Source# | Since: 4.9.0.0 |
| Ord (URecInt p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
| Show (URecInt p)Source# | Since: 4.9.0.0 |
| Generic (URecInt p)Source# | |
| dataURecInt (p :: k)Source# | Used for marking occurrences of Since: 4.9.0.0 |
| typeRep1 (URecInt :: k ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
| typeRep (URecInt p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.
| EnumFloatSource# | Since: 2.1 |
Instance detailsDefined inGHC.Float | |
| EqFloat | Note that due to the presence of
Also note that
|
| FloatingFloatSource# | Since: 2.1 |
| FractionalFloatSource# | Note that due to the presence of
Since: 2.1 |
| DataFloatSource# | Since: 4.0.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Float -> cFloatSource# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> cFloatSource# toConstr ::Float ->ConstrSource# dataTypeOf ::Float ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (cFloat)Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (cFloat)Source# gmapT :: (forall b.Data b => b -> b) ->Float ->FloatSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Float -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Float -> rSource# gmapQ :: (forall d.Data d => d -> u) ->Float -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->Float -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->Float -> mFloatSource# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Float -> mFloatSource# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Float -> mFloatSource# | |
| NumFloatSource# | Note that due to the presence of
Also note that due to the presence of -0,
Since: 2.1 |
| OrdFloat | Note that due to the presence of
Also note that, due to the same,
|
| ReadFloatSource# | Since: 2.1 |
| RealFloatSource# | Since: 2.1 |
| RealFloatFloatSource# | Since: 2.1 |
Instance detailsDefined inGHC.Float Methods floatRadix ::Float ->IntegerSource# floatDigits ::Float ->IntSource# floatRange ::Float -> (Int,Int)Source# decodeFloat ::Float -> (Integer,Int)Source# encodeFloat ::Integer ->Int ->FloatSource# significand ::Float ->FloatSource# scaleFloat ::Int ->Float ->FloatSource# isInfinite ::Float ->BoolSource# isDenormalized ::Float ->BoolSource# | |
| RealFracFloatSource# | Since: 2.1 |
| ShowFloatSource# | Since: 2.1 |
| StorableFloatSource# | Since: 2.1 |
| PrintfArgFloatSource# | Since: 2.1 |
Instance detailsDefined inText.Printf | |
| Generic1 (URecFloat :: k ->Type)Source# | |
| Functor (URecFloat ::Type ->Type)Source# | Since: 4.9.0.0 |
| Foldable (URecFloat ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>URecFloat m -> mSource# foldMap ::Monoid m => (a -> m) ->URecFloat a -> mSource# foldr :: (a -> b -> b) -> b ->URecFloat a -> bSource# foldr' :: (a -> b -> b) -> b ->URecFloat a -> bSource# foldl :: (b -> a -> b) -> b ->URecFloat a -> bSource# foldl' :: (b -> a -> b) -> b ->URecFloat a -> bSource# foldr1 :: (a -> a -> a) ->URecFloat a -> aSource# foldl1 :: (a -> a -> a) ->URecFloat a -> aSource# toList ::URecFloat a -> [a]Source# null ::URecFloat a ->BoolSource# length ::URecFloat a ->IntSource# elem ::Eq a => a ->URecFloat a ->BoolSource# maximum ::Ord a =>URecFloat a -> aSource# minimum ::Ord a =>URecFloat a -> aSource# | |
| Traversable (URecFloat ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| Eq (URecFloat p)Source# | |
| Ord (URecFloat p)Source# | |
| Show (URecFloat p)Source# | |
| Generic (URecFloat p)Source# | |
| dataURecFloat (p :: k)Source# | Used for marking occurrences of Since: 4.9.0.0 |
| typeRep1 (URecFloat :: k ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
| typeRep (URecFloat p)Source# | |
Instance detailsDefined inGHC.Generics | |
Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.
| EnumDoubleSource# | Since: 2.1 |
| EqDouble | Note that due to the presence of
Also note that
|
| FloatingDoubleSource# | Since: 2.1 |
Instance detailsDefined inGHC.Float | |
| FractionalDoubleSource# | Note that due to the presence of
Since: 2.1 |
| DataDoubleSource# | Since: 4.0.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Double -> cDoubleSource# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> cDoubleSource# toConstr ::Double ->ConstrSource# dataTypeOf ::Double ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (cDouble)Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (cDouble)Source# gmapT :: (forall b.Data b => b -> b) ->Double ->DoubleSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Double -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Double -> rSource# gmapQ :: (forall d.Data d => d -> u) ->Double -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->Double -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->Double -> mDoubleSource# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Double -> mDoubleSource# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Double -> mDoubleSource# | |
| NumDoubleSource# | Note that due to the presence of
Also note that due to the presence of -0,
Since: 2.1 |
| OrdDouble | Note that due to the presence of
Also note that, due to the same,
|
| ReadDoubleSource# | Since: 2.1 |
| RealDoubleSource# | Since: 2.1 |
| RealFloatDoubleSource# | Since: 2.1 |
Instance detailsDefined inGHC.Float Methods floatRadix ::Double ->IntegerSource# floatDigits ::Double ->IntSource# floatRange ::Double -> (Int,Int)Source# decodeFloat ::Double -> (Integer,Int)Source# encodeFloat ::Integer ->Int ->DoubleSource# exponent ::Double ->IntSource# significand ::Double ->DoubleSource# scaleFloat ::Int ->Double ->DoubleSource# isInfinite ::Double ->BoolSource# isDenormalized ::Double ->BoolSource# | |
| RealFracDoubleSource# | Since: 2.1 |
| ShowDoubleSource# | Since: 2.1 |
| StorableDoubleSource# | Since: 2.1 |
Instance detailsDefined inForeign.Storable | |
| PrintfArgDoubleSource# | Since: 2.1 |
Instance detailsDefined inText.Printf | |
| Generic1 (URecDouble :: k ->Type)Source# | |
| Functor (URecDouble ::Type ->Type)Source# | Since: 4.9.0.0 |
| Foldable (URecDouble ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>URecDouble m -> mSource# foldMap ::Monoid m => (a -> m) ->URecDouble a -> mSource# foldr :: (a -> b -> b) -> b ->URecDouble a -> bSource# foldr' :: (a -> b -> b) -> b ->URecDouble a -> bSource# foldl :: (b -> a -> b) -> b ->URecDouble a -> bSource# foldl' :: (b -> a -> b) -> b ->URecDouble a -> bSource# foldr1 :: (a -> a -> a) ->URecDouble a -> aSource# foldl1 :: (a -> a -> a) ->URecDouble a -> aSource# toList ::URecDouble a -> [a]Source# null ::URecDouble a ->BoolSource# length ::URecDouble a ->IntSource# elem ::Eq a => a ->URecDouble a ->BoolSource# maximum ::Ord a =>URecDouble a -> aSource# minimum ::Ord a =>URecDouble a -> aSource# | |
| Traversable (URecDouble ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| Eq (URecDouble p)Source# | Since: 4.9.0.0 |
| Ord (URecDouble p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
| Show (URecDouble p)Source# | Since: 4.9.0.0 |
| Generic (URecDouble p)Source# | |
| dataURecDouble (p :: k)Source# | Used for marking occurrences of Since: 4.9.0.0 |
| typeRep1 (URecDouble :: k ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
| typeRep (URecDouble p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
The character typeChar is an enumeration whose values representUnicode (or equivalently ISO/IEC 10646) code points (i.e. characters, seehttp://www.unicode.org/ for details). This set extends the ISO 8859-1(Latin-1) character set (the first 256 characters), which is itself an extensionof the ASCII character set (the first 128 characters). A character literal inHaskell has typeChar.
To convert aChar to or from the correspondingInt value definedby Unicode, usetoEnum andfromEnum from theEnum class respectively (or equivalentlyord andchr).
| BoundedCharSource# | Since: 2.1 |
| EnumCharSource# | Since: 2.1 |
Instance detailsDefined inGHC.Enum | |
| EqChar | |
| DataCharSource# | Since: 4.0.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Char -> cCharSource# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> cCharSource# toConstr ::Char ->ConstrSource# dataTypeOf ::Char ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (cChar)Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (cChar)Source# gmapT :: (forall b.Data b => b -> b) ->Char ->CharSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Char -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Char -> rSource# gmapQ :: (forall d.Data d => d -> u) ->Char -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->Char -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->Char -> mCharSource# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Char -> mCharSource# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Char -> mCharSource# | |
| OrdChar | |
| ReadCharSource# | Since: 2.1 |
| ShowCharSource# | Since: 2.1 |
| IxCharSource# | Since: 2.1 |
| StorableCharSource# | Since: 2.1 |
| IsCharCharSource# | Since: 2.1 |
| PrintfArgCharSource# | Since: 2.1 |
Instance detailsDefined inText.Printf | |
| Generic1 (URecChar :: k ->Type)Source# | |
| Functor (URecChar ::Type ->Type)Source# | Since: 4.9.0.0 |
| Foldable (URecChar ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>URecChar m -> mSource# foldMap ::Monoid m => (a -> m) ->URecChar a -> mSource# foldr :: (a -> b -> b) -> b ->URecChar a -> bSource# foldr' :: (a -> b -> b) -> b ->URecChar a -> bSource# foldl :: (b -> a -> b) -> b ->URecChar a -> bSource# foldl' :: (b -> a -> b) -> b ->URecChar a -> bSource# foldr1 :: (a -> a -> a) ->URecChar a -> aSource# foldl1 :: (a -> a -> a) ->URecChar a -> aSource# toList ::URecChar a -> [a]Source# null ::URecChar a ->BoolSource# length ::URecChar a ->IntSource# elem ::Eq a => a ->URecChar a ->BoolSource# maximum ::Ord a =>URecChar a -> aSource# minimum ::Ord a =>URecChar a -> aSource# | |
| Traversable (URecChar ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| Eq (URecChar p)Source# | Since: 4.9.0.0 |
| Ord (URecChar p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
| Show (URecChar p)Source# | Since: 4.9.0.0 |
| Generic (URecChar p)Source# | |
| dataURecChar (p :: k)Source# | Used for marking occurrences of Since: 4.9.0.0 |
| typeRep1 (URecChar :: k ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
| typeRep (URecChar p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
A value of typePtr aa.
The typea will often be an instance of classStorable which provides the marshalling operations. However this is not essential, and you can provide your own operations to access the pointer. For example you might write small foreign functions to get or set the fields of a Cstruct.
| Generic1 (URec (Ptr ()) :: k ->Type)Source# | |
| Eq (Ptr a)Source# | Since: 2.1 |
| Data a =>Data (Ptr a)Source# | Since: 4.8.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Ptr a -> c (Ptr a)Source# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (Ptr a)Source# toConstr ::Ptr a ->ConstrSource# dataTypeOf ::Ptr a ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (Ptr a))Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (Ptr a))Source# gmapT :: (forall b.Data b => b -> b) ->Ptr a ->Ptr aSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Ptr a -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Ptr a -> rSource# gmapQ :: (forall d.Data d => d -> u) ->Ptr a -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->Ptr a -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->Ptr a -> m (Ptr a)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Ptr a -> m (Ptr a)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Ptr a -> m (Ptr a)Source# | |
| Ord (Ptr a)Source# | Since: 2.1 |
| Show (Ptr a)Source# | Since: 2.1 |
| Storable (Ptr a)Source# | Since: 2.1 |
Instance detailsDefined inForeign.Storable | |
| Functor (URec (Ptr ()) ::Type ->Type)Source# | Since: 4.9.0.0 |
| Foldable (URec (Ptr ()) ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>URec (Ptr ()) m -> mSource# foldMap ::Monoid m => (a -> m) ->URec (Ptr ()) a -> mSource# foldr :: (a -> b -> b) -> b ->URec (Ptr ()) a -> bSource# foldr' :: (a -> b -> b) -> b ->URec (Ptr ()) a -> bSource# foldl :: (b -> a -> b) -> b ->URec (Ptr ()) a -> bSource# foldl' :: (b -> a -> b) -> b ->URec (Ptr ()) a -> bSource# foldr1 :: (a -> a -> a) ->URec (Ptr ()) a -> aSource# foldl1 :: (a -> a -> a) ->URec (Ptr ()) a -> aSource# toList ::URec (Ptr ()) a -> [a]Source# null ::URec (Ptr ()) a ->BoolSource# length ::URec (Ptr ()) a ->IntSource# elem ::Eq a => a ->URec (Ptr ()) a ->BoolSource# maximum ::Ord a =>URec (Ptr ()) a -> aSource# minimum ::Ord a =>URec (Ptr ()) a -> aSource# | |
| Traversable (URec (Ptr ()) ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable Methods traverse ::Applicative f => (a -> f b) ->URec (Ptr ()) a -> f (URec (Ptr ()) b)Source# sequenceA ::Applicative f =>URec (Ptr ()) (f a) -> f (URec (Ptr ()) a)Source# mapM ::Monad m => (a -> m b) ->URec (Ptr ()) a -> m (URec (Ptr ()) b)Source# sequence ::Monad m =>URec (Ptr ()) (m a) -> m (URec (Ptr ()) a)Source# | |
| Eq (URec (Ptr ()) p)Source# | Since: 4.9.0.0 |
| Ord (URec (Ptr ()) p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics Methods compare ::URec (Ptr ()) p ->URec (Ptr ()) p ->Ordering# (<) ::URec (Ptr ()) p ->URec (Ptr ()) p ->Bool# (<=) ::URec (Ptr ()) p ->URec (Ptr ()) p ->Bool# (>) ::URec (Ptr ()) p ->URec (Ptr ()) p ->Bool# (>=) ::URec (Ptr ()) p ->URec (Ptr ()) p ->Bool# | |
| Generic (URec (Ptr ()) p)Source# | |
| dataURec (Ptr ()) (p :: k)Source# | Used for marking occurrences of Since: 4.9.0.0 |
| typeRep1 (URec (Ptr ()) :: k ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
| typeRep (URec (Ptr ()) p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
A value of typeFunPtr aa will normally be aforeign type, a function type with zero or more arguments where
Char,Int,Double,Float,Bool,Int8,Int16,Int32,Int64,Word8,Word16,Word32,Word64,Ptr aFunPtr aStablePtr anewtype.IO tt is a marshallable foreign type or().A value of typeFunPtr a
foreign import ccall "stdlib.h &free" p_free :: FunPtr (Ptr a -> IO ())
or a pointer to a Haskell function created using awrapper stub declared to produce aFunPtr of the correct type. For example:
type Compare = Int -> Int -> Boolforeign import ccall "wrapper" mkCompare :: Compare -> IO (FunPtr Compare)
Calls to wrapper stubs likemkCompare allocate storage, which should be released withfreeHaskellFunPtr when no longer required.
To convertFunPtr values to corresponding Haskell functions, one can define adynamic stub for the specific foreign type, e.g.
type IntFunction = CInt -> IO ()foreign import ccall "dynamic" mkFun :: FunPtr IntFunction -> IntFunction
| Eq (FunPtr a)Source# | |
| Ord (FunPtr a)Source# | |
| Show (FunPtr a)Source# | Since: 2.1 |
| Storable (FunPtr a)Source# | Since: 2.1 |
Instance detailsDefined inForeign.Storable Methods sizeOf ::FunPtr a ->IntSource# alignment ::FunPtr a ->IntSource# peekElemOff ::Ptr (FunPtr a) ->Int ->IO (FunPtr a)Source# pokeElemOff ::Ptr (FunPtr a) ->Int ->FunPtr a ->IO ()Source# peekByteOff ::Ptr b ->Int ->IO (FunPtr a)Source# pokeByteOff ::Ptr b ->Int ->FunPtr a ->IO ()Source# | |
The value ofseq a b is bottom ifa is bottom, and otherwise equal tob. In other words, it evaluates the first argumenta to weak head normal form (WHNF).seq is usually introduced to improve performance by avoiding unneeded laziness.
A note on evaluation order: the expressionseq a b doesnot guarantee thata will be evaluated beforeb. The only guarantee given byseq is that the botha andb will be evaluated beforeseq returns a value. In particular, this means thatb may be evaluated beforea. If you need to guarantee a specific order of evaluation, you must use the functionpseq from the "parallel" package.
unsafeCoerce# :: a -> b#
The functionunsafeCoerce# allows you to side-step the typechecker entirely. That is, it allows you to coerce any type into any other type. If you use this function, you had better get it right, otherwise segmentation faults await. It is generally used when you want to write a program that you know is well-typed, but where Haskell's type system is not expressive enough to prove that it is well typed.
The following uses ofunsafeCoerce# are supposed to work (i.e. not lead to spurious compile-time or run-time crashes):
AnyAny back to the real typeGHC.Float module for functions to do work.)Ptr Int toPtr Float, or[Int] to[Float] when the list is known to be empty. Also, anewtype of a typeT has the same representation at runtime asT.Other uses ofunsafeCoerce# are undefined. In particular, you should not useunsafeCoerce# to cast a T to an algebraic data type D, unless T is also an algebraic data type. For example, do not castInt->Int toBool, even if you later cast thatBool back toInt->Int before applying it. The reasons have to do with GHC's internal representation details (for the cognoscenti, data values can be entered but function closures cannot). If you want a safe type to cast things to, useAny, which is not an algebraic data type.
An arbitrary machine address assumed to point outside the garbage-collected heap.
dataByteArray# ::TYPEUnliftedRep#
dataMutableArray# (a ::Type) (b ::Type) ::Type ->Type ->TYPEUnliftedRep#
dataMutableByteArray# (a ::Type) ::Type ->TYPEUnliftedRep#
dataMVar# (a ::Type) (b ::Type) ::Type ->Type ->TYPEUnliftedRep#
A shared mutable variable (not the same as aMutVar#!). (Note: in a non-concurrent implementation,(MVar# a) can be represented by(MutVar# (Maybe a)).)
RealWorld is deeply magical. It isprimitive, but it is notunlifted (henceptrArg). We never manipulate values of typeRealWorld; it's only used in the type system, to parameteriseState#.
dataArrayArray# ::TYPEUnliftedRep#
dataMutableArrayArray# (a ::Type) ::Type ->TYPEUnliftedRep#
dataState# (a ::Type) ::Type ->TYPE (TupleRep ([] :: [RuntimeRep]))#
State# is the primitive, unlifted type of states. It has one type parameter, thusState# RealWorld, orState# s, where s is a type variable. The only purpose of the type parameter is to keep different state threads separate. It is represented by nothing at all.
dataStableName# (a ::Type) ::Type ->TYPEUnliftedRep#
dataMutVar# (a ::Type) (b ::Type) ::Type ->Type ->TYPEUnliftedRep#
AMutVar# behaves like a single-element mutable array.
dataVoid# ::TYPE (TupleRep ([] :: [RuntimeRep]))#
dataThreadId# ::TYPEUnliftedRep#
(In a non-concurrent implementation, this can be a singleton type, whose (unique) value is returned bymyThreadId#. The other operations can be omitted.)
dataBCO# ::TYPEUnliftedRep#
Primitive bytecode type.
dataCompact# ::TYPEUnliftedRep#
dataProxy# ::forall k0. k0 ->TYPE (TupleRep ([] :: [RuntimeRep]))#
The type constructorProxy# is used to bear witness to some type variable. It's used when you want to pass around proxy values for doing things like modelling type applications. AProxy# is not only unboxed, it also has a polymorphic kind, and has no runtime representation, being totally free.
dataSmallArray# (a ::Type) ::Type ->TYPEUnliftedRep#
dataSmallMutableArray# (a ::Type) (b ::Type) ::Type ->Type ->TYPEUnliftedRep#
dataWord16X16# ::TYPE (VecRepVec16Word16ElemRep)#
dataWord16X32# ::TYPE (VecRepVec32Word16ElemRep)#
dataWord32X16# ::TYPE (VecRepVec16Word32ElemRep)#
mulIntMayOflo# ::Int# ->Int# ->Int##
Return non-zero if there is any possibility that the upper word of a signed integer multiply might contain useful information. Return zero only if you are completely sure that no overflow can occur. On a 32-bit platform, the recommended implementation is to do a 32 x 32 -> 64 signed multiply, and subtract result[63:32] from (result[31] >>signed 31). If this is zero, meaning that the upper word is merely a sign extension of the lower one, no overflow can occur.
On a 64-bit platform it is not always possible to acquire the top 64 bits of the result. Therefore, a recommended implementation is to take the absolute value of both operands, and return 0 iff bits[63:31] of them are zero, since that means that their magnitudes fit within 31 bits, so the magnitude of the product must fit into 62 bits.
If in doubt, return non-zero, but do make an effort to create the correct answer for small args, since otherwise the performance of(*) :: Integer -> Integer -> Integer will be poor.
quotInt# ::Int# ->Int# ->Int##
Rounds towards zero. The behavior is undefined if the second argument is zero.
Satisfies(quotInt# x y) *# y +# (remInt# x y) == x. The behavior is undefined if the second argument is zero.
negateInt# ::Int# ->Int##
addIntC# ::Int# ->Int# -> (#Int#,Int##)#
Add signed integers reporting overflow. First member of result is the sum truncated to anInt#; second member is zero if the true sum fits in anInt#, nonzero if overflow occurred (the sum is either too large or too small to fit in anInt#).
subIntC# ::Int# ->Int# -> (#Int#,Int##)#
Subtract signed integers reporting overflow. First member of result is the difference truncated to anInt#; second member is zero if the true difference fits in anInt#, nonzero if overflow occurred (the difference is either too large or too small to fit in anInt#).
int2Float# ::Int# ->Float##
int2Double# ::Int# ->Double##
word2Float# ::Word# ->Float##
uncheckedIShiftL# ::Int# ->Int# ->Int##
Shift left. Result undefined if shift amount is not in the range 0 to word size - 1 inclusive.
uncheckedIShiftRA# ::Int# ->Int# ->Int##
Shift right arithmetic. Result undefined if shift amount is not in the range 0 to word size - 1 inclusive.
uncheckedIShiftRL# ::Int# ->Int# ->Int##
Shift right logical. Result undefined if shift amount is not in the range 0 to word size - 1 inclusive.
addWordC# ::Word# ->Word# -> (#Word#,Int##)#
Add unsigned integers reporting overflow. The first element of the pair is the result. The second element is the carry flag, which is nonzero on overflow. See alsoplusWord2#.
subWordC# ::Word# ->Word# -> (#Word#,Int##)#
Subtract unsigned integers reporting overflow. The first element of the pair is the result. The second element is the carry flag, which is nonzero on overflow.
plusWord2# ::Word# ->Word# -> (#Word#,Word##)#
Add unsigned integers, with the high part (carry) in the first component of the returned pair and the low part in the second component of the pair. See alsoaddWordC#.
minusWord# ::Word# ->Word# ->Word##
timesWord# ::Word# ->Word# ->Word##
uncheckedShiftL# ::Word# ->Int# ->Word##
Shift left logical. Result undefined if shift amount is not in the range 0 to word size - 1 inclusive.
uncheckedShiftRL# ::Word# ->Int# ->Word##
Shift right logical. Result undefined if shift amount is not in the range 0 to word size - 1 inclusive.
pdep8# ::Word# ->Word# ->Word##
Deposit bits to lower 8 bits of a word at locations specified by a mask.
pdep16# ::Word# ->Word# ->Word##
Deposit bits to lower 16 bits of a word at locations specified by a mask.
pdep32# ::Word# ->Word# ->Word##
Deposit bits to lower 32 bits of a word at locations specified by a mask.
pext8# ::Word# ->Word# ->Word##
Extract bits from lower 8 bits of a word at locations specified by a mask.
pext16# ::Word# ->Word# ->Word##
Extract bits from lower 16 bits of a word at locations specified by a mask.
pext32# ::Word# ->Word# ->Word##
Extract bits from lower 32 bits of a word at locations specified by a mask.
byteSwap16# ::Word# ->Word##
Swap bytes in the lower 16 bits of a word. The higher bytes are undefined.
byteSwap32# ::Word# ->Word##
Swap bytes in the lower 32 bits of a word. The higher bytes are undefined.
byteSwap64# ::Word# ->Word##
Swap bytes in a 64 bits of a word.
narrow8Int# ::Int# ->Int##
narrow16Int# ::Int# ->Int##
narrow32Int# ::Int# ->Int##
narrow8Word# ::Word# ->Word##
narrow16Word# ::Word# ->Word##
narrow32Word# ::Word# ->Word##
double2Int# ::Double# ->Int##
Truncates aDouble# value to the nearestInt#. Results are undefined if the truncation if truncation yields a value outside the range ofInt#.
decodeDouble_2Int# ::Double# -> (#Int#,Word#,Word#,Int##)#
Convert to integer. First component of the result is -1 or 1, indicating the sign of the mantissa. The next two are the high and low 32 bits of the mantissa respectively, and the last is the exponent.
decodeDouble_Int64# ::Double# -> (#Int#,Int##)#
DecodeDouble# into mantissa and base-2 exponent.
plusFloat# ::Float# ->Float# ->Float##
minusFloat# ::Float# ->Float# ->Float##
timesFloat# ::Float# ->Float# ->Float##
divideFloat# ::Float# ->Float# ->Float##
fabsFloat# ::Float# ->Float##
float2Int# ::Float# ->Int##
Truncates aFloat# value to the nearestInt#. Results are undefined if the truncation if truncation yields a value outside the range ofInt#.
sqrtFloat# ::Float# ->Float##
asinFloat# ::Float# ->Float##
acosFloat# ::Float# ->Float##
atanFloat# ::Float# ->Float##
sinhFloat# ::Float# ->Float##
coshFloat# ::Float# ->Float##
tanhFloat# ::Float# ->Float##
powerFloat# ::Float# ->Float# ->Float##
decodeFloat_Int# ::Float# -> (#Int#,Int##)#
Convert to integers. FirstInt# in result is the mantissa; second is the exponent.
newArray# ::Int# -> a ->State# d -> (#State# d,MutableArray# d a#)#
Create a new mutable array with the specified number of elements, in the specified state thread, with each element containing the specified initial value.
sameMutableArray# ::MutableArray# d a ->MutableArray# d a ->Int##
readArray# ::MutableArray# d a ->Int# ->State# d -> (#State# d, a#)#
Read from specified index of mutable array. Result is not yet evaluated.
writeArray# ::MutableArray# d a ->Int# -> a ->State# d ->State# d#
Write to specified index of mutable array.
sizeofArray# ::Array# a ->Int##
Return the number of elements in the array.
sizeofMutableArray# ::MutableArray# d a ->Int##
Return the number of elements in the array.
indexArray# ::Array# a ->Int# -> (#a#)#
Read from the specified index of an immutable array. The result is packaged into an unboxed unary tuple; the result itself is not yet evaluated. Pattern matching on the tuple forces the indexing of the array to happen but does not evaluate the element itself. Evaluating the thunk prevents additional thunks from building up on the heap. Avoiding these thunks, in turn, reduces references to the argument array, allowing it to be garbage collected more promptly.
unsafeFreezeArray# ::MutableArray# d a ->State# d -> (#State# d,Array# a#)#
Make a mutable array immutable, without copying.
unsafeThawArray# ::Array# a ->State# d -> (#State# d,MutableArray# d a#)#
Make an immutable array mutable, without copying.
copyArray# ::Array# a ->Int# ->MutableArray# d a ->Int# ->Int# ->State# d ->State# d#
Given a source array, an offset into the source array, a destination array, an offset into the destination array, and a number of elements to copy, copy the elements from the source array to the destination array. Both arrays must fully contain the specified ranges, but this is not checked. The two arrays must not be the same array in different states, but this is not checked either.
copyMutableArray# ::MutableArray# d a ->Int# ->MutableArray# d a ->Int# ->Int# ->State# d ->State# d#
Given a source array, an offset into the source array, a destination array, an offset into the destination array, and a number of elements to copy, copy the elements from the source array to the destination array. Both arrays must fully contain the specified ranges, but this is not checked. In the case where the source and destination are the same array the source and destination regions may overlap.
cloneArray# ::Array# a ->Int# ->Int# ->Array# a#
Given a source array, an offset into the source array, and a number of elements to copy, create a new array with the elements from the source array. The provided array must fully contain the specified range, but this is not checked.
cloneMutableArray# ::MutableArray# d a ->Int# ->Int# ->State# d -> (#State# d,MutableArray# d a#)#
Given a source array, an offset into the source array, and a number of elements to copy, create a new array with the elements from the source array. The provided array must fully contain the specified range, but this is not checked.
freezeArray# ::MutableArray# d a ->Int# ->Int# ->State# d -> (#State# d,Array# a#)#
Given a source array, an offset into the source array, and a number of elements to copy, create a new array with the elements from the source array. The provided array must fully contain the specified range, but this is not checked.
thawArray# ::Array# a ->Int# ->Int# ->State# d -> (#State# d,MutableArray# d a#)#
Given a source array, an offset into the source array, and a number of elements to copy, create a new array with the elements from the source array. The provided array must fully contain the specified range, but this is not checked.
casArray# ::MutableArray# d a ->Int# -> a -> a ->State# d -> (#State# d,Int#, a#)#
Unsafe, machine-level atomic compare and swap on an element within an Array.
newSmallArray# ::Int# -> a ->State# d -> (#State# d,SmallMutableArray# d a#)#
Create a new mutable array with the specified number of elements, in the specified state thread, with each element containing the specified initial value.
sameSmallMutableArray# ::SmallMutableArray# d a ->SmallMutableArray# d a ->Int##
readSmallArray# ::SmallMutableArray# d a ->Int# ->State# d -> (#State# d, a#)#
Read from specified index of mutable array. Result is not yet evaluated.
writeSmallArray# ::SmallMutableArray# d a ->Int# -> a ->State# d ->State# d#
Write to specified index of mutable array.
sizeofSmallArray# ::SmallArray# a ->Int##
Return the number of elements in the array.
sizeofSmallMutableArray# ::SmallMutableArray# d a ->Int##
Return the number of elements in the array.
indexSmallArray# ::SmallArray# a ->Int# -> (#a#)#
Read from specified index of immutable array. Result is packaged into an unboxed singleton; the result itself is not yet evaluated.
unsafeFreezeSmallArray# ::SmallMutableArray# d a ->State# d -> (#State# d,SmallArray# a#)#
Make a mutable array immutable, without copying.
unsafeThawSmallArray# ::SmallArray# a ->State# d -> (#State# d,SmallMutableArray# d a#)#
Make an immutable array mutable, without copying.
copySmallArray# ::SmallArray# a ->Int# ->SmallMutableArray# d a ->Int# ->Int# ->State# d ->State# d#
Given a source array, an offset into the source array, a destination array, an offset into the destination array, and a number of elements to copy, copy the elements from the source array to the destination array. Both arrays must fully contain the specified ranges, but this is not checked. The two arrays must not be the same array in different states, but this is not checked either.
copySmallMutableArray# ::SmallMutableArray# d a ->Int# ->SmallMutableArray# d a ->Int# ->Int# ->State# d ->State# d#
Given a source array, an offset into the source array, a destination array, an offset into the destination array, and a number of elements to copy, copy the elements from the source array to the destination array. The source and destination arrays can refer to the same array. Both arrays must fully contain the specified ranges, but this is not checked. The regions are allowed to overlap, although this is only possible when the same array is provided as both the source and the destination.
cloneSmallArray# ::SmallArray# a ->Int# ->Int# ->SmallArray# a#
Given a source array, an offset into the source array, and a number of elements to copy, create a new array with the elements from the source array. The provided array must fully contain the specified range, but this is not checked.
cloneSmallMutableArray# ::SmallMutableArray# d a ->Int# ->Int# ->State# d -> (#State# d,SmallMutableArray# d a#)#
Given a source array, an offset into the source array, and a number of elements to copy, create a new array with the elements from the source array. The provided array must fully contain the specified range, but this is not checked.
freezeSmallArray# ::SmallMutableArray# d a ->Int# ->Int# ->State# d -> (#State# d,SmallArray# a#)#
Given a source array, an offset into the source array, and a number of elements to copy, create a new array with the elements from the source array. The provided array must fully contain the specified range, but this is not checked.
thawSmallArray# ::SmallArray# a ->Int# ->Int# ->State# d -> (#State# d,SmallMutableArray# d a#)#
Given a source array, an offset into the source array, and a number of elements to copy, create a new array with the elements from the source array. The provided array must fully contain the specified range, but this is not checked.
casSmallArray# ::SmallMutableArray# d a ->Int# -> a -> a ->State# d -> (#State# d,Int#, a#)#
Unsafe, machine-level atomic compare and swap on an element within an array.
newByteArray# ::Int# ->State# d -> (#State# d,MutableByteArray# d#)#
Create a new mutable byte array of specified size (in bytes), in the specified state thread.
newPinnedByteArray# ::Int# ->State# d -> (#State# d,MutableByteArray# d#)#
Create a mutable byte array that the GC guarantees not to move.
newAlignedPinnedByteArray# ::Int# ->Int# ->State# d -> (#State# d,MutableByteArray# d#)#
Create a mutable byte array, aligned by the specified amount, that the GC guarantees not to move.
isMutableByteArrayPinned# ::MutableByteArray# d ->Int##
Determine whether aMutableByteArray# is guaranteed not to move during GC.
isByteArrayPinned# ::ByteArray# ->Int##
Determine whether aByteArray# is guaranteed not to move during GC.
byteArrayContents# ::ByteArray# ->Addr##
Intended for use with pinned arrays; otherwise very unsafe!
shrinkMutableByteArray# ::MutableByteArray# d ->Int# ->State# d ->State# d#
Shrink mutable byte array to new specified size (in bytes), in the specified state thread. The new size argument must be less than or equal to the current size as reported bysizeofMutableArray#.
resizeMutableByteArray# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,MutableByteArray# d#)#
Resize (unpinned) mutable byte array to new specified size (in bytes). The returnedMutableByteArray# is either the originalMutableByteArray# resized in-place or, if not possible, a newly allocated (unpinned)MutableByteArray# (with the original content copied over).
To avoid undefined behaviour, the originalMutableByteArray# shall not be accessed anymore after aresizeMutableByteArray# has been performed. Moreover, no reference to the old one should be kept in order to allow garbage collection of the originalMutableByteArray# in case a newMutableByteArray# had to be allocated.
unsafeFreezeByteArray# ::MutableByteArray# d ->State# d -> (#State# d,ByteArray##)#
Make a mutable byte array immutable, without copying.
sizeofByteArray# ::ByteArray# ->Int##
Return the size of the array in bytes.
sizeofMutableByteArray# ::MutableByteArray# d ->Int##
Return the size of the array in bytes. Note that this is deprecated as it is unsafe in the presence of concurrent resize operations on the same byte array. SeegetSizeofMutableByteArray.
getSizeofMutableByteArray# ::MutableByteArray# d ->State# d -> (#State# d,Int##)#
Return the number of elements in the array.
indexCharArray# ::ByteArray# ->Int# ->Char##
Read 8-bit character; offset in bytes.
indexWideCharArray# ::ByteArray# ->Int# ->Char##
Read 31-bit character; offset in 4-byte words.
indexIntArray# ::ByteArray# ->Int# ->Int##
indexWordArray# ::ByteArray# ->Int# ->Word##
indexAddrArray# ::ByteArray# ->Int# ->Addr##
indexInt8Array# ::ByteArray# ->Int# ->Int##
Read 8-bit integer; offset in bytes.
indexInt16Array# ::ByteArray# ->Int# ->Int##
Read 16-bit integer; offset in 16-bit words.
indexInt32Array# ::ByteArray# ->Int# ->Int##
Read 32-bit integer; offset in 32-bit words.
indexInt64Array# ::ByteArray# ->Int# ->Int##
Read 64-bit integer; offset in 64-bit words.
indexWord8Array# ::ByteArray# ->Int# ->Word##
Read 8-bit word; offset in bytes.
indexWord16Array# ::ByteArray# ->Int# ->Word##
Read 16-bit word; offset in 16-bit words.
indexWord32Array# ::ByteArray# ->Int# ->Word##
Read 32-bit word; offset in 32-bit words.
indexWord64Array# ::ByteArray# ->Int# ->Word##
Read 64-bit word; offset in 64-bit words.
indexWord8ArrayAsChar# ::ByteArray# ->Int# ->Char##
Read 8-bit character; offset in bytes.
indexWord8ArrayAsWideChar# ::ByteArray# ->Int# ->Char##
Read 31-bit character; offset in bytes.
indexWord8ArrayAsAddr# ::ByteArray# ->Int# ->Addr##
Read address; offset in bytes.
indexWord8ArrayAsFloat# ::ByteArray# ->Int# ->Float##
Read float; offset in bytes.
indexWord8ArrayAsDouble# ::ByteArray# ->Int# ->Double##
Read double; offset in bytes.
indexWord8ArrayAsStablePtr# ::ByteArray# ->Int# ->StablePtr# a#
Read stable pointer; offset in bytes.
indexWord8ArrayAsInt16# ::ByteArray# ->Int# ->Int##
Read 16-bit int; offset in bytes.
indexWord8ArrayAsInt32# ::ByteArray# ->Int# ->Int##
Read 32-bit int; offset in bytes.
indexWord8ArrayAsInt64# ::ByteArray# ->Int# ->Int##
Read 64-bit int; offset in bytes.
indexWord8ArrayAsInt# ::ByteArray# ->Int# ->Int##
Read int; offset in bytes.
indexWord8ArrayAsWord16# ::ByteArray# ->Int# ->Word##
Read 16-bit word; offset in bytes.
indexWord8ArrayAsWord32# ::ByteArray# ->Int# ->Word##
Read 32-bit word; offset in bytes.
indexWord8ArrayAsWord64# ::ByteArray# ->Int# ->Word##
Read 64-bit word; offset in bytes.
indexWord8ArrayAsWord# ::ByteArray# ->Int# ->Word##
Read word; offset in bytes.
readCharArray# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Char##)#
Read 8-bit character; offset in bytes.
readWideCharArray# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Char##)#
Read 31-bit character; offset in 4-byte words.
readIntArray# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int##)#
Read integer; offset in words.
readWordArray# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word##)#
Read word; offset in words.
readAddrArray# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Addr##)#
readFloatArray# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Float##)#
readDoubleArray# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Double##)#
readStablePtrArray# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,StablePtr# a#)#
readInt8Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int##)#
readInt16Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int##)#
readInt32Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int##)#
readInt64Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int##)#
readWord8Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word##)#
readWord16Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word##)#
readWord32Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word##)#
readWord64Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word##)#
readWord8ArrayAsChar# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Char##)#
readWord8ArrayAsWideChar# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Char##)#
readWord8ArrayAsAddr# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Addr##)#
readWord8ArrayAsFloat# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Float##)#
readWord8ArrayAsDouble# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Double##)#
readWord8ArrayAsStablePtr# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,StablePtr# a#)#
readWord8ArrayAsInt16# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int##)#
readWord8ArrayAsInt32# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int##)#
readWord8ArrayAsInt64# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int##)#
readWord8ArrayAsInt# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int##)#
readWord8ArrayAsWord16# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word##)#
readWord8ArrayAsWord32# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word##)#
readWord8ArrayAsWord64# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word##)#
readWord8ArrayAsWord# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word##)#
writeCharArray# ::MutableByteArray# d ->Int# ->Char# ->State# d ->State# d#
Write 8-bit character; offset in bytes.
writeWideCharArray# ::MutableByteArray# d ->Int# ->Char# ->State# d ->State# d#
Write 31-bit character; offset in 4-byte words.
writeIntArray# ::MutableByteArray# d ->Int# ->Int# ->State# d ->State# d#
writeWordArray# ::MutableByteArray# d ->Int# ->Word# ->State# d ->State# d#
writeAddrArray# ::MutableByteArray# d ->Int# ->Addr# ->State# d ->State# d#
writeFloatArray# ::MutableByteArray# d ->Int# ->Float# ->State# d ->State# d#
writeDoubleArray# ::MutableByteArray# d ->Int# ->Double# ->State# d ->State# d#
writeStablePtrArray# ::MutableByteArray# d ->Int# ->StablePtr# a ->State# d ->State# d#
writeInt8Array# ::MutableByteArray# d ->Int# ->Int# ->State# d ->State# d#
writeInt16Array# ::MutableByteArray# d ->Int# ->Int# ->State# d ->State# d#
writeInt32Array# ::MutableByteArray# d ->Int# ->Int# ->State# d ->State# d#
writeInt64Array# ::MutableByteArray# d ->Int# ->Int# ->State# d ->State# d#
writeWord8Array# ::MutableByteArray# d ->Int# ->Word# ->State# d ->State# d#
writeWord16Array# ::MutableByteArray# d ->Int# ->Word# ->State# d ->State# d#
writeWord32Array# ::MutableByteArray# d ->Int# ->Word# ->State# d ->State# d#
writeWord64Array# ::MutableByteArray# d ->Int# ->Word# ->State# d ->State# d#
writeWord8ArrayAsChar# ::MutableByteArray# d ->Int# ->Char# ->State# d ->State# d#
writeWord8ArrayAsWideChar# ::MutableByteArray# d ->Int# ->Char# ->State# d ->State# d#
writeWord8ArrayAsAddr# ::MutableByteArray# d ->Int# ->Addr# ->State# d ->State# d#
writeWord8ArrayAsFloat# ::MutableByteArray# d ->Int# ->Float# ->State# d ->State# d#
writeWord8ArrayAsDouble# ::MutableByteArray# d ->Int# ->Double# ->State# d ->State# d#
writeWord8ArrayAsStablePtr# ::MutableByteArray# d ->Int# ->StablePtr# a ->State# d ->State# d#
writeWord8ArrayAsInt16# ::MutableByteArray# d ->Int# ->Int# ->State# d ->State# d#
writeWord8ArrayAsInt32# ::MutableByteArray# d ->Int# ->Int# ->State# d ->State# d#
writeWord8ArrayAsInt64# ::MutableByteArray# d ->Int# ->Int# ->State# d ->State# d#
writeWord8ArrayAsInt# ::MutableByteArray# d ->Int# ->Int# ->State# d ->State# d#
writeWord8ArrayAsWord16# ::MutableByteArray# d ->Int# ->Word# ->State# d ->State# d#
writeWord8ArrayAsWord32# ::MutableByteArray# d ->Int# ->Word# ->State# d ->State# d#
writeWord8ArrayAsWord64# ::MutableByteArray# d ->Int# ->Word# ->State# d ->State# d#
writeWord8ArrayAsWord# ::MutableByteArray# d ->Int# ->Word# ->State# d ->State# d#
compareByteArrays# ::ByteArray# ->Int# ->ByteArray# ->Int# ->Int# ->Int##
compareByteArrays# src1 src1_ofs src2 src2_ofs n comparesn bytes starting at offsetsrc1_ofs in the firstByteArray#src1 to the range ofn bytes (i.e. same length) starting at offsetsrc2_ofs of the secondByteArray#src2. Both arrays must fully contain the specified ranges, but this is not checked. Returns anInt# less than, equal to, or greater than zero if the range is found, respectively, to be byte-wise lexicographically less than, to match, or be greater than the second range.
copyByteArray# ::ByteArray# ->Int# ->MutableByteArray# d ->Int# ->Int# ->State# d ->State# d#
copyByteArray# src src_ofs dst dst_ofs n copies the range starting at offsetsrc_ofs of lengthn from theByteArray#src to theMutableByteArray#dst starting at offsetdst_ofs. Both arrays must fully contain the specified ranges, but this is not checked. The two arrays must not be the same array in different states, but this is not checked either.
copyMutableByteArray# ::MutableByteArray# d ->Int# ->MutableByteArray# d ->Int# ->Int# ->State# d ->State# d#
copyByteArrayToAddr# ::ByteArray# ->Int# ->Addr# ->Int# ->State# d ->State# d#
copyMutableByteArrayToAddr# ::MutableByteArray# d ->Int# ->Addr# ->Int# ->State# d ->State# d#
copyAddrToByteArray# ::Addr# ->MutableByteArray# d ->Int# ->Int# ->State# d ->State# d#
setByteArray# ::MutableByteArray# d ->Int# ->Int# ->Int# ->State# d ->State# d#
setByteArray# ba off len c sets the byte range[off, off+len] of theMutableByteArray# to the bytec.
atomicReadIntArray# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int##)#
Given an array and an offset in Int units, read an element. The index is assumed to be in bounds. Implies a full memory barrier.
atomicWriteIntArray# ::MutableByteArray# d ->Int# ->Int# ->State# d ->State# d#
Given an array and an offset in Int units, write an element. The index is assumed to be in bounds. Implies a full memory barrier.
casIntArray# ::MutableByteArray# d ->Int# ->Int# ->Int# ->State# d -> (#State# d,Int##)#
Given an array, an offset in Int units, the expected old value, and the new value, perform an atomic compare and swap i.e. write the new value if the current value matches the provided old value. Returns the value of the element before the operation. Implies a full memory barrier.
fetchAddIntArray# ::MutableByteArray# d ->Int# ->Int# ->State# d -> (#State# d,Int##)#
Given an array, and offset in Int units, and a value to add, atomically add the value to the element. Returns the value of the element before the operation. Implies a full memory barrier.
fetchSubIntArray# ::MutableByteArray# d ->Int# ->Int# ->State# d -> (#State# d,Int##)#
Given an array, and offset in Int units, and a value to subtract, atomically substract the value to the element. Returns the value of the element before the operation. Implies a full memory barrier.
fetchAndIntArray# ::MutableByteArray# d ->Int# ->Int# ->State# d -> (#State# d,Int##)#
Given an array, and offset in Int units, and a value to AND, atomically AND the value to the element. Returns the value of the element before the operation. Implies a full memory barrier.
fetchNandIntArray# ::MutableByteArray# d ->Int# ->Int# ->State# d -> (#State# d,Int##)#
Given an array, and offset in Int units, and a value to NAND, atomically NAND the value to the element. Returns the value of the element before the operation. Implies a full memory barrier.
fetchOrIntArray# ::MutableByteArray# d ->Int# ->Int# ->State# d -> (#State# d,Int##)#
Given an array, and offset in Int units, and a value to OR, atomically OR the value to the element. Returns the value of the element before the operation. Implies a full memory barrier.
fetchXorIntArray# ::MutableByteArray# d ->Int# ->Int# ->State# d -> (#State# d,Int##)#
Given an array, and offset in Int units, and a value to XOR, atomically XOR the value to the element. Returns the value of the element before the operation. Implies a full memory barrier.
newArrayArray# ::Int# ->State# d -> (#State# d,MutableArrayArray# d#)#
Create a new mutable array of arrays with the specified number of elements, in the specified state thread, with each element recursively referring to the newly created array.
unsafeFreezeArrayArray# ::MutableArrayArray# d ->State# d -> (#State# d,ArrayArray##)#
Make a mutable array of arrays immutable, without copying.
sizeofArrayArray# ::ArrayArray# ->Int##
Return the number of elements in the array.
sizeofMutableArrayArray# ::MutableArrayArray# d ->Int##
Return the number of elements in the array.
readByteArrayArray# ::MutableArrayArray# d ->Int# ->State# d -> (#State# d,ByteArray##)#
readMutableByteArrayArray# ::MutableArrayArray# d ->Int# ->State# d -> (#State# d,MutableByteArray# d#)#
readArrayArrayArray# ::MutableArrayArray# d ->Int# ->State# d -> (#State# d,ArrayArray##)#
readMutableArrayArrayArray# ::MutableArrayArray# d ->Int# ->State# d -> (#State# d,MutableArrayArray# d#)#
writeByteArrayArray# ::MutableArrayArray# d ->Int# ->ByteArray# ->State# d ->State# d#
writeMutableByteArrayArray# ::MutableArrayArray# d ->Int# ->MutableByteArray# d ->State# d ->State# d#
writeArrayArrayArray# ::MutableArrayArray# d ->Int# ->ArrayArray# ->State# d ->State# d#
writeMutableArrayArrayArray# ::MutableArrayArray# d ->Int# ->MutableArrayArray# d ->State# d ->State# d#
copyArrayArray# ::ArrayArray# ->Int# ->MutableArrayArray# d ->Int# ->Int# ->State# d ->State# d#
copyMutableArrayArray# ::MutableArrayArray# d ->Int# ->MutableArrayArray# d ->Int# ->Int# ->State# d ->State# d#
Copy a range of the first MutableArrayArray# to the specified region in the second MutableArrayArray#. Both arrays must fully contain the specified ranges, but this is not checked. The regions are allowed to overlap, although this is only possible when the same array is provided as both the source and the destination.
minusAddr# ::Addr# ->Addr# ->Int##
Result is meaningless if twoAddr#s are so far apart that their difference doesn't fit in anInt#.
remAddr# ::Addr# ->Int# ->Int##
Return the remainder when theAddr# arg, treated like anInt#, is divided by theInt# arg.
indexCharOffAddr# ::Addr# ->Int# ->Char##
Reads 8-bit character; offset in bytes.
indexWideCharOffAddr# ::Addr# ->Int# ->Char##
Reads 31-bit character; offset in 4-byte words.
indexIntOffAddr# ::Addr# ->Int# ->Int##
indexWordOffAddr# ::Addr# ->Int# ->Word##
indexAddrOffAddr# ::Addr# ->Int# ->Addr##
indexFloatOffAddr# ::Addr# ->Int# ->Float##
indexDoubleOffAddr# ::Addr# ->Int# ->Double##
indexStablePtrOffAddr# ::Addr# ->Int# ->StablePtr# a#
indexInt8OffAddr# ::Addr# ->Int# ->Int##
indexInt16OffAddr# ::Addr# ->Int# ->Int##
indexInt32OffAddr# ::Addr# ->Int# ->Int##
indexInt64OffAddr# ::Addr# ->Int# ->Int##
indexWord8OffAddr# ::Addr# ->Int# ->Word##
indexWord16OffAddr# ::Addr# ->Int# ->Word##
indexWord32OffAddr# ::Addr# ->Int# ->Word##
indexWord64OffAddr# ::Addr# ->Int# ->Word##
readCharOffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Char##)#
Reads 8-bit character; offset in bytes.
readWideCharOffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Char##)#
Reads 31-bit character; offset in 4-byte words.
readStablePtrOffAddr# ::Addr# ->Int# ->State# d -> (#State# d,StablePtr# a#)#
writeStablePtrOffAddr# ::Addr# ->Int# ->StablePtr# a ->State# d ->State# d#
newMutVar# :: a ->State# d -> (#State# d,MutVar# d a#)#
CreateMutVar# with specified initial value in specified state thread.
readMutVar# ::MutVar# d a ->State# d -> (#State# d, a#)#
Read contents ofMutVar#. Result is not yet evaluated.
writeMutVar# ::MutVar# d a -> a ->State# d ->State# d#
Write contents ofMutVar#.
sameMutVar# ::MutVar# d a ->MutVar# d a ->Int##
atomicModifyMutVar# ::MutVar# d a -> (a -> b) ->State# d -> (#State# d, c#)#
catch# :: (State#RealWorld -> (#State#RealWorld, a#)) -> (b ->State#RealWorld -> (#State#RealWorld, a#)) ->State#RealWorld -> (#State#RealWorld, a#)#
maskAsyncExceptions# :: (State#RealWorld -> (#State#RealWorld, a#)) ->State#RealWorld -> (#State#RealWorld, a#)#
maskUninterruptible# :: (State#RealWorld -> (#State#RealWorld, a#)) ->State#RealWorld -> (#State#RealWorld, a#)#
unmaskAsyncExceptions# :: (State#RealWorld -> (#State#RealWorld, a#)) ->State#RealWorld -> (#State#RealWorld, a#)#
atomically# :: (State#RealWorld -> (#State#RealWorld, a#)) ->State#RealWorld -> (#State#RealWorld, a#)#
catchRetry# :: (State#RealWorld -> (#State#RealWorld, a#)) -> (State#RealWorld -> (#State#RealWorld, a#)) ->State#RealWorld -> (#State#RealWorld, a#)#
catchSTM# :: (State#RealWorld -> (#State#RealWorld, a#)) -> (b ->State#RealWorld -> (#State#RealWorld, a#)) ->State#RealWorld -> (#State#RealWorld, a#)#
newTVar# :: a ->State# d -> (#State# d,TVar# d a#)#
Create a newTVar# holding a specified initial value.
readTVar# ::TVar# d a ->State# d -> (#State# d, a#)#
Read contents ofTVar#. Result is not yet evaluated.
readTVarIO# ::TVar# d a ->State# d -> (#State# d, a#)#
Read contents ofTVar# outside an STM transaction
writeTVar# ::TVar# d a -> a ->State# d ->State# d#
Write contents ofTVar#.
takeMVar# ::MVar# d a ->State# d -> (#State# d, a#)#
IfMVar# is empty, block until it becomes full. Then remove and return its contents, and set it empty.
tryTakeMVar# ::MVar# d a ->State# d -> (#State# d,Int#, a#)#
IfMVar# is empty, immediately return with integer 0 and value undefined. Otherwise, return with integer 1 and contents ofMVar#, and setMVar# empty.
putMVar# ::MVar# d a -> a ->State# d ->State# d#
IfMVar# is full, block until it becomes empty. Then store value arg as its new contents.
tryPutMVar# ::MVar# d a -> a ->State# d -> (#State# d,Int##)#
IfMVar# is full, immediately return with integer 0. Otherwise, store value arg asMVar#'s new contents, and return with integer 1.
readMVar# ::MVar# d a ->State# d -> (#State# d, a#)#
IfMVar# is empty, block until it becomes full. Then read its contents without modifying the MVar, without possibility of intervention from other threads.
tryReadMVar# ::MVar# d a ->State# d -> (#State# d,Int#, a#)#
IfMVar# is empty, immediately return with integer 0 and value undefined. Otherwise, return with integer 1 and contents ofMVar#.
waitWrite# ::Int# ->State# d ->State# d#
Block until output is possible on specified file descriptor.
noDuplicate# ::State# d ->State# d#
mkWeak# :: a -> b -> (State#RealWorld -> (#State#RealWorld, c#)) ->State#RealWorld -> (#State#RealWorld,Weak# b#)#
mkWeak# k v finalizer s creates a weak reference to valuek, with an associated reference to some valuev. Ifk is still alive thenv can be retrieved usingdeRefWeak#. Note that the type ofk must be represented by a pointer (i.e. of kindTYPE 'LiftedRep orTYPE 'UnliftedRep).
addCFinalizerToWeak# ::Addr# ->Addr# ->Int# ->Addr# ->Weak# b ->State#RealWorld -> (#State#RealWorld,Int##)#
addCFinalizerToWeak# fptr ptr flag eptr w attaches a C function pointerfptr to a weak pointerw as a finalizer. Ifflag is zero,fptr will be called with one argument,ptr. Otherwise, it will be called with two arguments,eptr andptr.addCFinalizerToWeak# returns 1 on success, or 0 ifw is already dead.
finalizeWeak# ::Weak# a ->State#RealWorld -> (#State#RealWorld,Int#,State#RealWorld -> (#State#RealWorld, b#)#)#
Finalize a weak pointer. The return value is an unboxed tuple containing the new state of the world and an "unboxed Maybe", represented by anInt# and a (possibly invalid) finalization action. AnInt# of1 indicates that the finalizer is valid. The return valueb from the finalizer should be ignored.
makeStablePtr# :: a ->State#RealWorld -> (#State#RealWorld,StablePtr# a#)#
deRefStablePtr# ::StablePtr# a ->State#RealWorld -> (#State#RealWorld, a#)#
eqStablePtr# ::StablePtr# a ->StablePtr# a ->Int##
makeStableName# :: a ->State#RealWorld -> (#State#RealWorld,StableName# a#)#
eqStableName# ::StableName# a ->StableName# b ->Int##
stableNameToInt# ::StableName# a ->Int##
compactNew# ::Word# ->State#RealWorld -> (#State#RealWorld,Compact##)#
Create a new Compact with the given size (in bytes, not words). The size is rounded up to a multiple of the allocator block size, and capped to one mega block.
compactResize# ::Compact# ->Word# ->State#RealWorld ->State#RealWorld#
Set the new allocation size of the compact. This value (in bytes) determines the size of each block in the compact chain.
compactGetFirstBlock# ::Compact# ->State#RealWorld -> (#State#RealWorld,Addr#,Word##)#
Returns the address and the size (in bytes) of the first block of a compact.
compactGetNextBlock# ::Compact# ->Addr# ->State#RealWorld -> (#State#RealWorld,Addr#,Word##)#
Given a compact and the address of one its blocks, returns the next block and its size, or #nullAddr if the argument was the last block in the compact.
compactAllocateBlock# ::Word# ->Addr# ->State#RealWorld -> (#State#RealWorld,Addr##)#
Attempt to allocate a compact block with the given size (in bytes) at the given address. The first argument is a hint to the allocator, allocation might be satisfied at a different address (which is returned). The resulting block is not known to the GC until compactFixupPointers# is called on it, and care must be taken so that the address does not escape or memory will be leaked.
compactFixupPointers# ::Addr# ->Addr# ->State#RealWorld -> (#State#RealWorld,Compact#,Addr##)#
Given the pointer to the first block of a compact, and the address of the root object in the old address space, fix up the internal pointers inside the compact to account for a different position in memory than when it was serialized. This method must be called exactly once after importing a serialized compact, and returns the new compact and the new adjusted root address.
compactAdd# ::Compact# -> a ->State#RealWorld -> (#State#RealWorld, a#)#
Recursively add a closure and its transitive closure to a {texttt Compact#}, evaluating any unevaluated components at the same time. Note: {texttt compactAdd#} is not thread-safe, so only one thread may call {texttt compactAdd#} with a particular {texttt Compact#} at any given time. The primop does not enforce any mutual exclusion; the caller is expected to arrange this.
compactAddWithSharing# ::Compact# -> a ->State#RealWorld -> (#State#RealWorld, a#)#
Like {texttt compactAdd#}, but retains sharing and cycles during compaction.
compactSize# ::Compact# ->State#RealWorld -> (#State#RealWorld,Word##)#
Return the size (in bytes) of the total amount of data in the Compact#
reallyUnsafePtrEquality# :: a -> a ->Int##
Returns {texttt 1#} if the given pointers are equal and {texttt 0#} otherwise.
numSparks# ::State# d -> (#State# d,Int##)#
Returns the number of sparks in the local spark pool.
dataToTag# :: a ->Int##
tagToEnum# ::Int# -> a#
But now consider z. case x of y -> let v = dataToTag# y in ...
To improve floating, the FloatOut pass (deliberately) does a binder-swap on the case, to give z. case x of y -> let v = dataToTag# x in ...
Now FloatOut might float that v-binding outside the z. But that is bad because that might mean x gets evaluated much too early! (CorePrep adds an eval to a dataToTag# call, to ensure that the argument really is evaluated; see CorePrep Note [dataToTag magic].)
Solution: make DataToTag into a can_fail primop. That will stop it floating (see Note [PrimOp can_fail and has_side_effects] in PrimOp). It's a bit of a hack but never mind. -
addrToAny# ::Addr# -> (#a#)#
Convert anAddr# to a followable Any type.
anyToAddr# :: a ->State#RealWorld -> (#State#RealWorld,Addr##)#
Retrieve the address of any Haskell value. This is essentially an {texttt unsafeCoerce#}, but if implemented as such the core lint pass complains and fails to compile. As a primop, it is opaque to core/stg, and only appears in cmm (where the copy propagation pass will get rid of it). Note that "a" must be a value, not a thunk! It's too late for strictness analysis to enforce this, so you're on your own to guarantee this. Also note that {texttt Addr#} is not a GC pointer - up to you to guarantee that it does not become a dangling pointer immediately after you get it.
Wrap a BCO in aAP_UPD thunk which will be updated with the value of the BCO when evaluated.
newBCO# ::ByteArray# ->ByteArray# ->Array# a ->Int# ->ByteArray# ->State# d -> (#State# d,BCO##)#
newBCO# instrs lits ptrs arity bitmap creates a new bytecode object. The resulting object encodes a function of the given arity with the instructions encoded ininstrs, and a static reference table usage bitmap given bybitmap.
unpackClosure# :: a -> (#Addr#,ByteArray#,Array# b#)#
unpackClosure# closure copies the closure and pointers in the payload of the given closure into two new arrays, and returns a pointer to the first word of the closure's info table, a non-pointer array for the raw bytes of the closure, and a pointer array for the pointers in the payload.
getApStackVal# :: a ->Int# -> (#Int#, b#)#
getCurrentCCS# :: a ->State# d -> (#State# d,Addr##)#
Returns the currentCostCentreStack (value isNULL if not profiling). Takes a dummy argument which can be used to avoid the call togetCurrentCCS# being floated out by the simplifier, which would result in an uninformative stack ("CAF").
clearCCS# :: (State# d -> (#State# d, a#)) ->State# d -> (#State# d, a#)#
Run the supplied IO action with an empty CCS. For example, this is used by the interpreter to run an interpreted computation without the call stack showing that it was invoked from GHC.
traceEvent# ::Addr# ->State# d ->State# d#
Emits an event via the RTS tracing framework. The contents of the event is the zero-terminated byte string passed as the first argument. The event will be emitted either to the .eventlog file, or to stderr, depending on the runtime RTS flags.
traceMarker# ::Addr# ->State# d ->State# d#
Emits a marker event via the RTS tracing framework. The contents of the event is the zero-terminated byte string passed as the first argument. The event will be emitted either to the .eventlog file, or to stderr, depending on the runtime RTS flags.
getThreadAllocationCounter# ::State#RealWorld -> (#State#RealWorld,Int##)#
Retrieves the allocation counter for the current thread.
setThreadAllocationCounter# ::Int# ->State#RealWorld ->State#RealWorld#
Sets the allocation counter for the current thread to the given value.
broadcastInt8X16# ::Int# ->Int8X16##
Broadcast a scalar to all elements of a vector.
broadcastInt16X8# ::Int# ->Int16X8##
Broadcast a scalar to all elements of a vector.
broadcastInt32X4# ::Int# ->Int32X4##
Broadcast a scalar to all elements of a vector.
broadcastInt64X2# ::Int# ->Int64X2##
Broadcast a scalar to all elements of a vector.
broadcastInt8X32# ::Int# ->Int8X32##
Broadcast a scalar to all elements of a vector.
broadcastInt16X16# ::Int# ->Int16X16##
Broadcast a scalar to all elements of a vector.
broadcastInt32X8# ::Int# ->Int32X8##
Broadcast a scalar to all elements of a vector.
broadcastInt64X4# ::Int# ->Int64X4##
Broadcast a scalar to all elements of a vector.
broadcastInt8X64# ::Int# ->Int8X64##
Broadcast a scalar to all elements of a vector.
broadcastInt16X32# ::Int# ->Int16X32##
Broadcast a scalar to all elements of a vector.
broadcastInt32X16# ::Int# ->Int32X16##
Broadcast a scalar to all elements of a vector.
broadcastInt64X8# ::Int# ->Int64X8##
Broadcast a scalar to all elements of a vector.
broadcastWord8X16# ::Word# ->Word8X16##
Broadcast a scalar to all elements of a vector.
broadcastWord16X8# ::Word# ->Word16X8##
Broadcast a scalar to all elements of a vector.
broadcastWord32X4# ::Word# ->Word32X4##
Broadcast a scalar to all elements of a vector.
broadcastWord64X2# ::Word# ->Word64X2##
Broadcast a scalar to all elements of a vector.
broadcastWord8X32# ::Word# ->Word8X32##
Broadcast a scalar to all elements of a vector.
broadcastWord16X16# ::Word# ->Word16X16##
Broadcast a scalar to all elements of a vector.
broadcastWord32X8# ::Word# ->Word32X8##
Broadcast a scalar to all elements of a vector.
broadcastWord64X4# ::Word# ->Word64X4##
Broadcast a scalar to all elements of a vector.
broadcastWord8X64# ::Word# ->Word8X64##
Broadcast a scalar to all elements of a vector.
broadcastWord16X32# ::Word# ->Word16X32##
Broadcast a scalar to all elements of a vector.
broadcastWord32X16# ::Word# ->Word32X16##
Broadcast a scalar to all elements of a vector.
broadcastWord64X8# ::Word# ->Word64X8##
Broadcast a scalar to all elements of a vector.
broadcastFloatX4# ::Float# ->FloatX4##
Broadcast a scalar to all elements of a vector.
broadcastDoubleX2# ::Double# ->DoubleX2##
Broadcast a scalar to all elements of a vector.
broadcastFloatX8# ::Float# ->FloatX8##
Broadcast a scalar to all elements of a vector.
broadcastDoubleX4# ::Double# ->DoubleX4##
Broadcast a scalar to all elements of a vector.
broadcastFloatX16# ::Float# ->FloatX16##
Broadcast a scalar to all elements of a vector.
broadcastDoubleX8# ::Double# ->DoubleX8##
Broadcast a scalar to all elements of a vector.
packInt8X16# :: (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##) ->Int8X16##
Pack the elements of an unboxed tuple into a vector.
packInt16X8# :: (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##) ->Int16X8##
Pack the elements of an unboxed tuple into a vector.
packInt32X4# :: (#Int#,Int#,Int#,Int##) ->Int32X4##
Pack the elements of an unboxed tuple into a vector.
packInt64X2# :: (#Int#,Int##) ->Int64X2##
Pack the elements of an unboxed tuple into a vector.
packInt8X32# :: (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##) ->Int8X32##
Pack the elements of an unboxed tuple into a vector.
packInt16X16# :: (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##) ->Int16X16##
Pack the elements of an unboxed tuple into a vector.
packInt32X8# :: (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##) ->Int32X8##
Pack the elements of an unboxed tuple into a vector.
packInt64X4# :: (#Int#,Int#,Int#,Int##) ->Int64X4##
Pack the elements of an unboxed tuple into a vector.
packInt8X64# :: (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##) ->Int8X64##
Pack the elements of an unboxed tuple into a vector.
packInt16X32# :: (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##) ->Int16X32##
Pack the elements of an unboxed tuple into a vector.
packInt32X16# :: (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##) ->Int32X16##
Pack the elements of an unboxed tuple into a vector.
packInt64X8# :: (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##) ->Int64X8##
Pack the elements of an unboxed tuple into a vector.
packWord8X16# :: (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##) ->Word8X16##
Pack the elements of an unboxed tuple into a vector.
packWord16X8# :: (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##) ->Word16X8##
Pack the elements of an unboxed tuple into a vector.
packWord32X4# :: (#Word#,Word#,Word#,Word##) ->Word32X4##
Pack the elements of an unboxed tuple into a vector.
packWord64X2# :: (#Word#,Word##) ->Word64X2##
Pack the elements of an unboxed tuple into a vector.
packWord8X32# :: (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##) ->Word8X32##
Pack the elements of an unboxed tuple into a vector.
packWord16X16# :: (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##) ->Word16X16##
Pack the elements of an unboxed tuple into a vector.
packWord32X8# :: (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##) ->Word32X8##
Pack the elements of an unboxed tuple into a vector.
packWord64X4# :: (#Word#,Word#,Word#,Word##) ->Word64X4##
Pack the elements of an unboxed tuple into a vector.
packWord8X64# :: (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##) ->Word8X64##
Pack the elements of an unboxed tuple into a vector.
packWord16X32# :: (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##) ->Word16X32##
Pack the elements of an unboxed tuple into a vector.
packWord32X16# :: (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##) ->Word32X16##
Pack the elements of an unboxed tuple into a vector.
packWord64X8# :: (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##) ->Word64X8##
Pack the elements of an unboxed tuple into a vector.
packFloatX4# :: (#Float#,Float#,Float#,Float##) ->FloatX4##
Pack the elements of an unboxed tuple into a vector.
packDoubleX2# :: (#Double#,Double##) ->DoubleX2##
Pack the elements of an unboxed tuple into a vector.
packFloatX8# :: (#Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float##) ->FloatX8##
Pack the elements of an unboxed tuple into a vector.
packDoubleX4# :: (#Double#,Double#,Double#,Double##) ->DoubleX4##
Pack the elements of an unboxed tuple into a vector.
packFloatX16# :: (#Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float##) ->FloatX16##
Pack the elements of an unboxed tuple into a vector.
packDoubleX8# :: (#Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double##) ->DoubleX8##
Pack the elements of an unboxed tuple into a vector.
unpackInt8X16# ::Int8X16# -> (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackInt16X8# ::Int16X8# -> (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackInt32X4# ::Int32X4# -> (#Int#,Int#,Int#,Int##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackInt64X2# ::Int64X2# -> (#Int#,Int##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackInt8X32# ::Int8X32# -> (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackInt16X16# ::Int16X16# -> (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackInt32X8# ::Int32X8# -> (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackInt64X4# ::Int64X4# -> (#Int#,Int#,Int#,Int##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackInt8X64# ::Int8X64# -> (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackInt16X32# ::Int16X32# -> (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackInt32X16# ::Int32X16# -> (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackInt64X8# ::Int64X8# -> (#Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackWord8X16# ::Word8X16# -> (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackWord16X8# ::Word16X8# -> (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackWord32X4# ::Word32X4# -> (#Word#,Word#,Word#,Word##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackWord64X2# ::Word64X2# -> (#Word#,Word##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackWord8X32# ::Word8X32# -> (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackWord16X16# ::Word16X16# -> (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackWord32X8# ::Word32X8# -> (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackWord64X4# ::Word64X4# -> (#Word#,Word#,Word#,Word##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackWord8X64# ::Word8X64# -> (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackWord16X32# ::Word16X32# -> (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackWord32X16# ::Word32X16# -> (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackWord64X8# ::Word64X8# -> (#Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackFloatX4# ::FloatX4# -> (#Float#,Float#,Float#,Float##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackDoubleX2# ::DoubleX2# -> (#Double#,Double##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackFloatX8# ::FloatX8# -> (#Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackDoubleX4# ::DoubleX4# -> (#Double#,Double#,Double#,Double##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackFloatX16# ::FloatX16# -> (#Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float##)#
Unpack the elements of a vector into an unboxed tuple. #
unpackDoubleX8# ::DoubleX8# -> (#Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double##)#
Unpack the elements of a vector into an unboxed tuple. #
insertInt8X16# ::Int8X16# ->Int# ->Int# ->Int8X16##
Insert a scalar at the given position in a vector.
insertInt16X8# ::Int16X8# ->Int# ->Int# ->Int16X8##
Insert a scalar at the given position in a vector.
insertInt32X4# ::Int32X4# ->Int# ->Int# ->Int32X4##
Insert a scalar at the given position in a vector.
insertInt64X2# ::Int64X2# ->Int# ->Int# ->Int64X2##
Insert a scalar at the given position in a vector.
insertInt8X32# ::Int8X32# ->Int# ->Int# ->Int8X32##
Insert a scalar at the given position in a vector.
insertInt16X16# ::Int16X16# ->Int# ->Int# ->Int16X16##
Insert a scalar at the given position in a vector.
insertInt32X8# ::Int32X8# ->Int# ->Int# ->Int32X8##
Insert a scalar at the given position in a vector.
insertInt64X4# ::Int64X4# ->Int# ->Int# ->Int64X4##
Insert a scalar at the given position in a vector.
insertInt8X64# ::Int8X64# ->Int# ->Int# ->Int8X64##
Insert a scalar at the given position in a vector.
insertInt16X32# ::Int16X32# ->Int# ->Int# ->Int16X32##
Insert a scalar at the given position in a vector.
insertInt32X16# ::Int32X16# ->Int# ->Int# ->Int32X16##
Insert a scalar at the given position in a vector.
insertInt64X8# ::Int64X8# ->Int# ->Int# ->Int64X8##
Insert a scalar at the given position in a vector.
insertWord8X16# ::Word8X16# ->Word# ->Int# ->Word8X16##
Insert a scalar at the given position in a vector.
insertWord16X8# ::Word16X8# ->Word# ->Int# ->Word16X8##
Insert a scalar at the given position in a vector.
insertWord32X4# ::Word32X4# ->Word# ->Int# ->Word32X4##
Insert a scalar at the given position in a vector.
insertWord64X2# ::Word64X2# ->Word# ->Int# ->Word64X2##
Insert a scalar at the given position in a vector.
insertWord8X32# ::Word8X32# ->Word# ->Int# ->Word8X32##
Insert a scalar at the given position in a vector.
insertWord16X16# ::Word16X16# ->Word# ->Int# ->Word16X16##
Insert a scalar at the given position in a vector.
insertWord32X8# ::Word32X8# ->Word# ->Int# ->Word32X8##
Insert a scalar at the given position in a vector.
insertWord64X4# ::Word64X4# ->Word# ->Int# ->Word64X4##
Insert a scalar at the given position in a vector.
insertWord8X64# ::Word8X64# ->Word# ->Int# ->Word8X64##
Insert a scalar at the given position in a vector.
insertWord16X32# ::Word16X32# ->Word# ->Int# ->Word16X32##
Insert a scalar at the given position in a vector.
insertWord32X16# ::Word32X16# ->Word# ->Int# ->Word32X16##
Insert a scalar at the given position in a vector.
insertWord64X8# ::Word64X8# ->Word# ->Int# ->Word64X8##
Insert a scalar at the given position in a vector.
insertFloatX4# ::FloatX4# ->Float# ->Int# ->FloatX4##
Insert a scalar at the given position in a vector.
insertDoubleX2# ::DoubleX2# ->Double# ->Int# ->DoubleX2##
Insert a scalar at the given position in a vector.
insertFloatX8# ::FloatX8# ->Float# ->Int# ->FloatX8##
Insert a scalar at the given position in a vector.
insertDoubleX4# ::DoubleX4# ->Double# ->Int# ->DoubleX4##
Insert a scalar at the given position in a vector.
insertFloatX16# ::FloatX16# ->Float# ->Int# ->FloatX16##
Insert a scalar at the given position in a vector.
insertDoubleX8# ::DoubleX8# ->Double# ->Int# ->DoubleX8##
Insert a scalar at the given position in a vector.
plusInt8X16# ::Int8X16# ->Int8X16# ->Int8X16##
Add two vectors element-wise.
plusInt16X8# ::Int16X8# ->Int16X8# ->Int16X8##
Add two vectors element-wise.
plusInt32X4# ::Int32X4# ->Int32X4# ->Int32X4##
Add two vectors element-wise.
plusInt64X2# ::Int64X2# ->Int64X2# ->Int64X2##
Add two vectors element-wise.
plusInt8X32# ::Int8X32# ->Int8X32# ->Int8X32##
Add two vectors element-wise.
plusInt16X16# ::Int16X16# ->Int16X16# ->Int16X16##
Add two vectors element-wise.
plusInt32X8# ::Int32X8# ->Int32X8# ->Int32X8##
Add two vectors element-wise.
plusInt64X4# ::Int64X4# ->Int64X4# ->Int64X4##
Add two vectors element-wise.
plusInt8X64# ::Int8X64# ->Int8X64# ->Int8X64##
Add two vectors element-wise.
plusInt16X32# ::Int16X32# ->Int16X32# ->Int16X32##
Add two vectors element-wise.
plusInt32X16# ::Int32X16# ->Int32X16# ->Int32X16##
Add two vectors element-wise.
plusInt64X8# ::Int64X8# ->Int64X8# ->Int64X8##
Add two vectors element-wise.
plusWord8X16# ::Word8X16# ->Word8X16# ->Word8X16##
Add two vectors element-wise.
plusWord16X8# ::Word16X8# ->Word16X8# ->Word16X8##
Add two vectors element-wise.
plusWord32X4# ::Word32X4# ->Word32X4# ->Word32X4##
Add two vectors element-wise.
plusWord64X2# ::Word64X2# ->Word64X2# ->Word64X2##
Add two vectors element-wise.
plusWord8X32# ::Word8X32# ->Word8X32# ->Word8X32##
Add two vectors element-wise.
plusWord16X16# ::Word16X16# ->Word16X16# ->Word16X16##
Add two vectors element-wise.
plusWord32X8# ::Word32X8# ->Word32X8# ->Word32X8##
Add two vectors element-wise.
plusWord64X4# ::Word64X4# ->Word64X4# ->Word64X4##
Add two vectors element-wise.
plusWord8X64# ::Word8X64# ->Word8X64# ->Word8X64##
Add two vectors element-wise.
plusWord16X32# ::Word16X32# ->Word16X32# ->Word16X32##
Add two vectors element-wise.
plusWord32X16# ::Word32X16# ->Word32X16# ->Word32X16##
Add two vectors element-wise.
plusWord64X8# ::Word64X8# ->Word64X8# ->Word64X8##
Add two vectors element-wise.
plusFloatX4# ::FloatX4# ->FloatX4# ->FloatX4##
Add two vectors element-wise.
plusDoubleX2# ::DoubleX2# ->DoubleX2# ->DoubleX2##
Add two vectors element-wise.
plusFloatX8# ::FloatX8# ->FloatX8# ->FloatX8##
Add two vectors element-wise.
plusDoubleX4# ::DoubleX4# ->DoubleX4# ->DoubleX4##
Add two vectors element-wise.
plusFloatX16# ::FloatX16# ->FloatX16# ->FloatX16##
Add two vectors element-wise.
plusDoubleX8# ::DoubleX8# ->DoubleX8# ->DoubleX8##
Add two vectors element-wise.
minusInt8X16# ::Int8X16# ->Int8X16# ->Int8X16##
Subtract two vectors element-wise.
minusInt16X8# ::Int16X8# ->Int16X8# ->Int16X8##
Subtract two vectors element-wise.
minusInt32X4# ::Int32X4# ->Int32X4# ->Int32X4##
Subtract two vectors element-wise.
minusInt64X2# ::Int64X2# ->Int64X2# ->Int64X2##
Subtract two vectors element-wise.
minusInt8X32# ::Int8X32# ->Int8X32# ->Int8X32##
Subtract two vectors element-wise.
minusInt16X16# ::Int16X16# ->Int16X16# ->Int16X16##
Subtract two vectors element-wise.
minusInt32X8# ::Int32X8# ->Int32X8# ->Int32X8##
Subtract two vectors element-wise.
minusInt64X4# ::Int64X4# ->Int64X4# ->Int64X4##
Subtract two vectors element-wise.
minusInt8X64# ::Int8X64# ->Int8X64# ->Int8X64##
Subtract two vectors element-wise.
minusInt16X32# ::Int16X32# ->Int16X32# ->Int16X32##
Subtract two vectors element-wise.
minusInt32X16# ::Int32X16# ->Int32X16# ->Int32X16##
Subtract two vectors element-wise.
minusInt64X8# ::Int64X8# ->Int64X8# ->Int64X8##
Subtract two vectors element-wise.
minusWord8X16# ::Word8X16# ->Word8X16# ->Word8X16##
Subtract two vectors element-wise.
minusWord16X8# ::Word16X8# ->Word16X8# ->Word16X8##
Subtract two vectors element-wise.
minusWord32X4# ::Word32X4# ->Word32X4# ->Word32X4##
Subtract two vectors element-wise.
minusWord64X2# ::Word64X2# ->Word64X2# ->Word64X2##
Subtract two vectors element-wise.
minusWord8X32# ::Word8X32# ->Word8X32# ->Word8X32##
Subtract two vectors element-wise.
minusWord16X16# ::Word16X16# ->Word16X16# ->Word16X16##
Subtract two vectors element-wise.
minusWord32X8# ::Word32X8# ->Word32X8# ->Word32X8##
Subtract two vectors element-wise.
minusWord64X4# ::Word64X4# ->Word64X4# ->Word64X4##
Subtract two vectors element-wise.
minusWord8X64# ::Word8X64# ->Word8X64# ->Word8X64##
Subtract two vectors element-wise.
minusWord16X32# ::Word16X32# ->Word16X32# ->Word16X32##
Subtract two vectors element-wise.
minusWord32X16# ::Word32X16# ->Word32X16# ->Word32X16##
Subtract two vectors element-wise.
minusWord64X8# ::Word64X8# ->Word64X8# ->Word64X8##
Subtract two vectors element-wise.
minusFloatX4# ::FloatX4# ->FloatX4# ->FloatX4##
Subtract two vectors element-wise.
minusDoubleX2# ::DoubleX2# ->DoubleX2# ->DoubleX2##
Subtract two vectors element-wise.
minusFloatX8# ::FloatX8# ->FloatX8# ->FloatX8##
Subtract two vectors element-wise.
minusDoubleX4# ::DoubleX4# ->DoubleX4# ->DoubleX4##
Subtract two vectors element-wise.
minusFloatX16# ::FloatX16# ->FloatX16# ->FloatX16##
Subtract two vectors element-wise.
minusDoubleX8# ::DoubleX8# ->DoubleX8# ->DoubleX8##
Subtract two vectors element-wise.
timesInt8X16# ::Int8X16# ->Int8X16# ->Int8X16##
Multiply two vectors element-wise.
timesInt16X8# ::Int16X8# ->Int16X8# ->Int16X8##
Multiply two vectors element-wise.
timesInt32X4# ::Int32X4# ->Int32X4# ->Int32X4##
Multiply two vectors element-wise.
timesInt64X2# ::Int64X2# ->Int64X2# ->Int64X2##
Multiply two vectors element-wise.
timesInt8X32# ::Int8X32# ->Int8X32# ->Int8X32##
Multiply two vectors element-wise.
timesInt16X16# ::Int16X16# ->Int16X16# ->Int16X16##
Multiply two vectors element-wise.
timesInt32X8# ::Int32X8# ->Int32X8# ->Int32X8##
Multiply two vectors element-wise.
timesInt64X4# ::Int64X4# ->Int64X4# ->Int64X4##
Multiply two vectors element-wise.
timesInt8X64# ::Int8X64# ->Int8X64# ->Int8X64##
Multiply two vectors element-wise.
timesInt16X32# ::Int16X32# ->Int16X32# ->Int16X32##
Multiply two vectors element-wise.
timesInt32X16# ::Int32X16# ->Int32X16# ->Int32X16##
Multiply two vectors element-wise.
timesInt64X8# ::Int64X8# ->Int64X8# ->Int64X8##
Multiply two vectors element-wise.
timesWord8X16# ::Word8X16# ->Word8X16# ->Word8X16##
Multiply two vectors element-wise.
timesWord16X8# ::Word16X8# ->Word16X8# ->Word16X8##
Multiply two vectors element-wise.
timesWord32X4# ::Word32X4# ->Word32X4# ->Word32X4##
Multiply two vectors element-wise.
timesWord64X2# ::Word64X2# ->Word64X2# ->Word64X2##
Multiply two vectors element-wise.
timesWord8X32# ::Word8X32# ->Word8X32# ->Word8X32##
Multiply two vectors element-wise.
timesWord16X16# ::Word16X16# ->Word16X16# ->Word16X16##
Multiply two vectors element-wise.
timesWord32X8# ::Word32X8# ->Word32X8# ->Word32X8##
Multiply two vectors element-wise.
timesWord64X4# ::Word64X4# ->Word64X4# ->Word64X4##
Multiply two vectors element-wise.
timesWord8X64# ::Word8X64# ->Word8X64# ->Word8X64##
Multiply two vectors element-wise.
timesWord16X32# ::Word16X32# ->Word16X32# ->Word16X32##
Multiply two vectors element-wise.
timesWord32X16# ::Word32X16# ->Word32X16# ->Word32X16##
Multiply two vectors element-wise.
timesWord64X8# ::Word64X8# ->Word64X8# ->Word64X8##
Multiply two vectors element-wise.
timesFloatX4# ::FloatX4# ->FloatX4# ->FloatX4##
Multiply two vectors element-wise.
timesDoubleX2# ::DoubleX2# ->DoubleX2# ->DoubleX2##
Multiply two vectors element-wise.
timesFloatX8# ::FloatX8# ->FloatX8# ->FloatX8##
Multiply two vectors element-wise.
timesDoubleX4# ::DoubleX4# ->DoubleX4# ->DoubleX4##
Multiply two vectors element-wise.
timesFloatX16# ::FloatX16# ->FloatX16# ->FloatX16##
Multiply two vectors element-wise.
timesDoubleX8# ::DoubleX8# ->DoubleX8# ->DoubleX8##
Multiply two vectors element-wise.
divideFloatX4# ::FloatX4# ->FloatX4# ->FloatX4##
Divide two vectors element-wise.
divideDoubleX2# ::DoubleX2# ->DoubleX2# ->DoubleX2##
Divide two vectors element-wise.
divideFloatX8# ::FloatX8# ->FloatX8# ->FloatX8##
Divide two vectors element-wise.
divideDoubleX4# ::DoubleX4# ->DoubleX4# ->DoubleX4##
Divide two vectors element-wise.
divideFloatX16# ::FloatX16# ->FloatX16# ->FloatX16##
Divide two vectors element-wise.
divideDoubleX8# ::DoubleX8# ->DoubleX8# ->DoubleX8##
Divide two vectors element-wise.
quotInt8X16# ::Int8X16# ->Int8X16# ->Int8X16##
Rounds towards zero element-wise.
quotInt16X8# ::Int16X8# ->Int16X8# ->Int16X8##
Rounds towards zero element-wise.
quotInt32X4# ::Int32X4# ->Int32X4# ->Int32X4##
Rounds towards zero element-wise.
quotInt64X2# ::Int64X2# ->Int64X2# ->Int64X2##
Rounds towards zero element-wise.
quotInt8X32# ::Int8X32# ->Int8X32# ->Int8X32##
Rounds towards zero element-wise.
quotInt16X16# ::Int16X16# ->Int16X16# ->Int16X16##
Rounds towards zero element-wise.
quotInt32X8# ::Int32X8# ->Int32X8# ->Int32X8##
Rounds towards zero element-wise.
quotInt64X4# ::Int64X4# ->Int64X4# ->Int64X4##
Rounds towards zero element-wise.
quotInt8X64# ::Int8X64# ->Int8X64# ->Int8X64##
Rounds towards zero element-wise.
quotInt16X32# ::Int16X32# ->Int16X32# ->Int16X32##
Rounds towards zero element-wise.
quotInt32X16# ::Int32X16# ->Int32X16# ->Int32X16##
Rounds towards zero element-wise.
quotInt64X8# ::Int64X8# ->Int64X8# ->Int64X8##
Rounds towards zero element-wise.
quotWord8X16# ::Word8X16# ->Word8X16# ->Word8X16##
Rounds towards zero element-wise.
quotWord16X8# ::Word16X8# ->Word16X8# ->Word16X8##
Rounds towards zero element-wise.
quotWord32X4# ::Word32X4# ->Word32X4# ->Word32X4##
Rounds towards zero element-wise.
quotWord64X2# ::Word64X2# ->Word64X2# ->Word64X2##
Rounds towards zero element-wise.
quotWord8X32# ::Word8X32# ->Word8X32# ->Word8X32##
Rounds towards zero element-wise.
quotWord16X16# ::Word16X16# ->Word16X16# ->Word16X16##
Rounds towards zero element-wise.
quotWord32X8# ::Word32X8# ->Word32X8# ->Word32X8##
Rounds towards zero element-wise.
quotWord64X4# ::Word64X4# ->Word64X4# ->Word64X4##
Rounds towards zero element-wise.
quotWord8X64# ::Word8X64# ->Word8X64# ->Word8X64##
Rounds towards zero element-wise.
quotWord16X32# ::Word16X32# ->Word16X32# ->Word16X32##
Rounds towards zero element-wise.
quotWord32X16# ::Word32X16# ->Word32X16# ->Word32X16##
Rounds towards zero element-wise.
quotWord64X8# ::Word64X8# ->Word64X8# ->Word64X8##
Rounds towards zero element-wise.
remInt8X16# ::Int8X16# ->Int8X16# ->Int8X16##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remInt16X8# ::Int16X8# ->Int16X8# ->Int16X8##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remInt32X4# ::Int32X4# ->Int32X4# ->Int32X4##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remInt64X2# ::Int64X2# ->Int64X2# ->Int64X2##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remInt8X32# ::Int8X32# ->Int8X32# ->Int8X32##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remInt16X16# ::Int16X16# ->Int16X16# ->Int16X16##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remInt32X8# ::Int32X8# ->Int32X8# ->Int32X8##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remInt64X4# ::Int64X4# ->Int64X4# ->Int64X4##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remInt8X64# ::Int8X64# ->Int8X64# ->Int8X64##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remInt16X32# ::Int16X32# ->Int16X32# ->Int16X32##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remInt32X16# ::Int32X16# ->Int32X16# ->Int32X16##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remInt64X8# ::Int64X8# ->Int64X8# ->Int64X8##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remWord8X16# ::Word8X16# ->Word8X16# ->Word8X16##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remWord16X8# ::Word16X8# ->Word16X8# ->Word16X8##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remWord32X4# ::Word32X4# ->Word32X4# ->Word32X4##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remWord64X2# ::Word64X2# ->Word64X2# ->Word64X2##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remWord8X32# ::Word8X32# ->Word8X32# ->Word8X32##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remWord16X16# ::Word16X16# ->Word16X16# ->Word16X16##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remWord32X8# ::Word32X8# ->Word32X8# ->Word32X8##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remWord64X4# ::Word64X4# ->Word64X4# ->Word64X4##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remWord8X64# ::Word8X64# ->Word8X64# ->Word8X64##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remWord16X32# ::Word16X32# ->Word16X32# ->Word16X32##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remWord32X16# ::Word32X16# ->Word32X16# ->Word32X16##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
remWord64X8# ::Word64X8# ->Word64X8# ->Word64X8##
Satisfies(quot# x y) times# y plus# (rem# x y) == x.
negateInt8X16# ::Int8X16# ->Int8X16##
Negate element-wise.
negateInt16X8# ::Int16X8# ->Int16X8##
Negate element-wise.
negateInt32X4# ::Int32X4# ->Int32X4##
Negate element-wise.
negateInt64X2# ::Int64X2# ->Int64X2##
Negate element-wise.
negateInt8X32# ::Int8X32# ->Int8X32##
Negate element-wise.
negateInt16X16# ::Int16X16# ->Int16X16##
Negate element-wise.
negateInt32X8# ::Int32X8# ->Int32X8##
Negate element-wise.
negateInt64X4# ::Int64X4# ->Int64X4##
Negate element-wise.
negateInt8X64# ::Int8X64# ->Int8X64##
Negate element-wise.
negateInt16X32# ::Int16X32# ->Int16X32##
Negate element-wise.
negateInt32X16# ::Int32X16# ->Int32X16##
Negate element-wise.
negateInt64X8# ::Int64X8# ->Int64X8##
Negate element-wise.
negateFloatX4# ::FloatX4# ->FloatX4##
Negate element-wise.
negateDoubleX2# ::DoubleX2# ->DoubleX2##
Negate element-wise.
negateFloatX8# ::FloatX8# ->FloatX8##
Negate element-wise.
negateDoubleX4# ::DoubleX4# ->DoubleX4##
Negate element-wise.
negateFloatX16# ::FloatX16# ->FloatX16##
Negate element-wise.
negateDoubleX8# ::DoubleX8# ->DoubleX8##
Negate element-wise.
indexInt8X16Array# ::ByteArray# ->Int# ->Int8X16##
Read a vector from specified index of immutable array.
indexInt16X8Array# ::ByteArray# ->Int# ->Int16X8##
Read a vector from specified index of immutable array.
indexInt32X4Array# ::ByteArray# ->Int# ->Int32X4##
Read a vector from specified index of immutable array.
indexInt64X2Array# ::ByteArray# ->Int# ->Int64X2##
Read a vector from specified index of immutable array.
indexInt8X32Array# ::ByteArray# ->Int# ->Int8X32##
Read a vector from specified index of immutable array.
indexInt16X16Array# ::ByteArray# ->Int# ->Int16X16##
Read a vector from specified index of immutable array.
indexInt32X8Array# ::ByteArray# ->Int# ->Int32X8##
Read a vector from specified index of immutable array.
indexInt64X4Array# ::ByteArray# ->Int# ->Int64X4##
Read a vector from specified index of immutable array.
indexInt8X64Array# ::ByteArray# ->Int# ->Int8X64##
Read a vector from specified index of immutable array.
indexInt16X32Array# ::ByteArray# ->Int# ->Int16X32##
Read a vector from specified index of immutable array.
indexInt32X16Array# ::ByteArray# ->Int# ->Int32X16##
Read a vector from specified index of immutable array.
indexInt64X8Array# ::ByteArray# ->Int# ->Int64X8##
Read a vector from specified index of immutable array.
indexWord8X16Array# ::ByteArray# ->Int# ->Word8X16##
Read a vector from specified index of immutable array.
indexWord16X8Array# ::ByteArray# ->Int# ->Word16X8##
Read a vector from specified index of immutable array.
indexWord32X4Array# ::ByteArray# ->Int# ->Word32X4##
Read a vector from specified index of immutable array.
indexWord64X2Array# ::ByteArray# ->Int# ->Word64X2##
Read a vector from specified index of immutable array.
indexWord8X32Array# ::ByteArray# ->Int# ->Word8X32##
Read a vector from specified index of immutable array.
indexWord16X16Array# ::ByteArray# ->Int# ->Word16X16##
Read a vector from specified index of immutable array.
indexWord32X8Array# ::ByteArray# ->Int# ->Word32X8##
Read a vector from specified index of immutable array.
indexWord64X4Array# ::ByteArray# ->Int# ->Word64X4##
Read a vector from specified index of immutable array.
indexWord8X64Array# ::ByteArray# ->Int# ->Word8X64##
Read a vector from specified index of immutable array.
indexWord16X32Array# ::ByteArray# ->Int# ->Word16X32##
Read a vector from specified index of immutable array.
indexWord32X16Array# ::ByteArray# ->Int# ->Word32X16##
Read a vector from specified index of immutable array.
indexWord64X8Array# ::ByteArray# ->Int# ->Word64X8##
Read a vector from specified index of immutable array.
indexFloatX4Array# ::ByteArray# ->Int# ->FloatX4##
Read a vector from specified index of immutable array.
indexDoubleX2Array# ::ByteArray# ->Int# ->DoubleX2##
Read a vector from specified index of immutable array.
indexFloatX8Array# ::ByteArray# ->Int# ->FloatX8##
Read a vector from specified index of immutable array.
indexDoubleX4Array# ::ByteArray# ->Int# ->DoubleX4##
Read a vector from specified index of immutable array.
indexFloatX16Array# ::ByteArray# ->Int# ->FloatX16##
Read a vector from specified index of immutable array.
indexDoubleX8Array# ::ByteArray# ->Int# ->DoubleX8##
Read a vector from specified index of immutable array.
readInt8X16Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int8X16##)#
Read a vector from specified index of mutable array.
readInt16X8Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int16X8##)#
Read a vector from specified index of mutable array.
readInt32X4Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int32X4##)#
Read a vector from specified index of mutable array.
readInt64X2Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int64X2##)#
Read a vector from specified index of mutable array.
readInt8X32Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int8X32##)#
Read a vector from specified index of mutable array.
readInt16X16Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int16X16##)#
Read a vector from specified index of mutable array.
readInt32X8Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int32X8##)#
Read a vector from specified index of mutable array.
readInt64X4Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int64X4##)#
Read a vector from specified index of mutable array.
readInt8X64Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int8X64##)#
Read a vector from specified index of mutable array.
readInt16X32Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int16X32##)#
Read a vector from specified index of mutable array.
readInt32X16Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int32X16##)#
Read a vector from specified index of mutable array.
readInt64X8Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int64X8##)#
Read a vector from specified index of mutable array.
readWord8X16Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word8X16##)#
Read a vector from specified index of mutable array.
readWord16X8Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word16X8##)#
Read a vector from specified index of mutable array.
readWord32X4Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word32X4##)#
Read a vector from specified index of mutable array.
readWord64X2Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word64X2##)#
Read a vector from specified index of mutable array.
readWord8X32Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word8X32##)#
Read a vector from specified index of mutable array.
readWord16X16Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word16X16##)#
Read a vector from specified index of mutable array.
readWord32X8Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word32X8##)#
Read a vector from specified index of mutable array.
readWord64X4Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word64X4##)#
Read a vector from specified index of mutable array.
readWord8X64Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word8X64##)#
Read a vector from specified index of mutable array.
readWord16X32Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word16X32##)#
Read a vector from specified index of mutable array.
readWord32X16Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word32X16##)#
Read a vector from specified index of mutable array.
readWord64X8Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word64X8##)#
Read a vector from specified index of mutable array.
readFloatX4Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,FloatX4##)#
Read a vector from specified index of mutable array.
readDoubleX2Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,DoubleX2##)#
Read a vector from specified index of mutable array.
readFloatX8Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,FloatX8##)#
Read a vector from specified index of mutable array.
readDoubleX4Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,DoubleX4##)#
Read a vector from specified index of mutable array.
readFloatX16Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,FloatX16##)#
Read a vector from specified index of mutable array.
readDoubleX8Array# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,DoubleX8##)#
Read a vector from specified index of mutable array.
writeInt8X16Array# ::MutableByteArray# d ->Int# ->Int8X16# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeInt16X8Array# ::MutableByteArray# d ->Int# ->Int16X8# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeInt32X4Array# ::MutableByteArray# d ->Int# ->Int32X4# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeInt64X2Array# ::MutableByteArray# d ->Int# ->Int64X2# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeInt8X32Array# ::MutableByteArray# d ->Int# ->Int8X32# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeInt16X16Array# ::MutableByteArray# d ->Int# ->Int16X16# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeInt32X8Array# ::MutableByteArray# d ->Int# ->Int32X8# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeInt64X4Array# ::MutableByteArray# d ->Int# ->Int64X4# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeInt8X64Array# ::MutableByteArray# d ->Int# ->Int8X64# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeInt16X32Array# ::MutableByteArray# d ->Int# ->Int16X32# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeInt32X16Array# ::MutableByteArray# d ->Int# ->Int32X16# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeInt64X8Array# ::MutableByteArray# d ->Int# ->Int64X8# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeWord8X16Array# ::MutableByteArray# d ->Int# ->Word8X16# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeWord16X8Array# ::MutableByteArray# d ->Int# ->Word16X8# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeWord32X4Array# ::MutableByteArray# d ->Int# ->Word32X4# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeWord64X2Array# ::MutableByteArray# d ->Int# ->Word64X2# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeWord8X32Array# ::MutableByteArray# d ->Int# ->Word8X32# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeWord16X16Array# ::MutableByteArray# d ->Int# ->Word16X16# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeWord32X8Array# ::MutableByteArray# d ->Int# ->Word32X8# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeWord64X4Array# ::MutableByteArray# d ->Int# ->Word64X4# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeWord8X64Array# ::MutableByteArray# d ->Int# ->Word8X64# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeWord16X32Array# ::MutableByteArray# d ->Int# ->Word16X32# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeWord32X16Array# ::MutableByteArray# d ->Int# ->Word32X16# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeWord64X8Array# ::MutableByteArray# d ->Int# ->Word64X8# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeFloatX4Array# ::MutableByteArray# d ->Int# ->FloatX4# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeDoubleX2Array# ::MutableByteArray# d ->Int# ->DoubleX2# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeFloatX8Array# ::MutableByteArray# d ->Int# ->FloatX8# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeDoubleX4Array# ::MutableByteArray# d ->Int# ->DoubleX4# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeFloatX16Array# ::MutableByteArray# d ->Int# ->FloatX16# ->State# d ->State# d#
Write a vector to specified index of mutable array.
writeDoubleX8Array# ::MutableByteArray# d ->Int# ->DoubleX8# ->State# d ->State# d#
Write a vector to specified index of mutable array.
indexInt8X16OffAddr# ::Addr# ->Int# ->Int8X16##
Reads vector; offset in bytes.
indexInt16X8OffAddr# ::Addr# ->Int# ->Int16X8##
Reads vector; offset in bytes.
indexInt32X4OffAddr# ::Addr# ->Int# ->Int32X4##
Reads vector; offset in bytes.
indexInt64X2OffAddr# ::Addr# ->Int# ->Int64X2##
Reads vector; offset in bytes.
indexInt8X32OffAddr# ::Addr# ->Int# ->Int8X32##
Reads vector; offset in bytes.
indexInt16X16OffAddr# ::Addr# ->Int# ->Int16X16##
Reads vector; offset in bytes.
indexInt32X8OffAddr# ::Addr# ->Int# ->Int32X8##
Reads vector; offset in bytes.
indexInt64X4OffAddr# ::Addr# ->Int# ->Int64X4##
Reads vector; offset in bytes.
indexInt8X64OffAddr# ::Addr# ->Int# ->Int8X64##
Reads vector; offset in bytes.
indexInt16X32OffAddr# ::Addr# ->Int# ->Int16X32##
Reads vector; offset in bytes.
indexInt32X16OffAddr# ::Addr# ->Int# ->Int32X16##
Reads vector; offset in bytes.
indexInt64X8OffAddr# ::Addr# ->Int# ->Int64X8##
Reads vector; offset in bytes.
indexWord8X16OffAddr# ::Addr# ->Int# ->Word8X16##
Reads vector; offset in bytes.
indexWord16X8OffAddr# ::Addr# ->Int# ->Word16X8##
Reads vector; offset in bytes.
indexWord32X4OffAddr# ::Addr# ->Int# ->Word32X4##
Reads vector; offset in bytes.
indexWord64X2OffAddr# ::Addr# ->Int# ->Word64X2##
Reads vector; offset in bytes.
indexWord8X32OffAddr# ::Addr# ->Int# ->Word8X32##
Reads vector; offset in bytes.
indexWord16X16OffAddr# ::Addr# ->Int# ->Word16X16##
Reads vector; offset in bytes.
indexWord32X8OffAddr# ::Addr# ->Int# ->Word32X8##
Reads vector; offset in bytes.
indexWord64X4OffAddr# ::Addr# ->Int# ->Word64X4##
Reads vector; offset in bytes.
indexWord8X64OffAddr# ::Addr# ->Int# ->Word8X64##
Reads vector; offset in bytes.
indexWord16X32OffAddr# ::Addr# ->Int# ->Word16X32##
Reads vector; offset in bytes.
indexWord32X16OffAddr# ::Addr# ->Int# ->Word32X16##
Reads vector; offset in bytes.
indexWord64X8OffAddr# ::Addr# ->Int# ->Word64X8##
Reads vector; offset in bytes.
indexFloatX4OffAddr# ::Addr# ->Int# ->FloatX4##
Reads vector; offset in bytes.
indexDoubleX2OffAddr# ::Addr# ->Int# ->DoubleX2##
Reads vector; offset in bytes.
indexFloatX8OffAddr# ::Addr# ->Int# ->FloatX8##
Reads vector; offset in bytes.
indexDoubleX4OffAddr# ::Addr# ->Int# ->DoubleX4##
Reads vector; offset in bytes.
indexFloatX16OffAddr# ::Addr# ->Int# ->FloatX16##
Reads vector; offset in bytes.
indexDoubleX8OffAddr# ::Addr# ->Int# ->DoubleX8##
Reads vector; offset in bytes.
readInt8X16OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Int8X16##)#
Reads vector; offset in bytes.
readInt16X8OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Int16X8##)#
Reads vector; offset in bytes.
readInt32X4OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Int32X4##)#
Reads vector; offset in bytes.
readInt64X2OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Int64X2##)#
Reads vector; offset in bytes.
readInt8X32OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Int8X32##)#
Reads vector; offset in bytes.
readInt16X16OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Int16X16##)#
Reads vector; offset in bytes.
readInt32X8OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Int32X8##)#
Reads vector; offset in bytes.
readInt64X4OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Int64X4##)#
Reads vector; offset in bytes.
readInt8X64OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Int8X64##)#
Reads vector; offset in bytes.
readInt16X32OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Int16X32##)#
Reads vector; offset in bytes.
readInt32X16OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Int32X16##)#
Reads vector; offset in bytes.
readInt64X8OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Int64X8##)#
Reads vector; offset in bytes.
readWord8X16OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Word8X16##)#
Reads vector; offset in bytes.
readWord16X8OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Word16X8##)#
Reads vector; offset in bytes.
readWord32X4OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Word32X4##)#
Reads vector; offset in bytes.
readWord64X2OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Word64X2##)#
Reads vector; offset in bytes.
readWord8X32OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Word8X32##)#
Reads vector; offset in bytes.
readWord16X16OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Word16X16##)#
Reads vector; offset in bytes.
readWord32X8OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Word32X8##)#
Reads vector; offset in bytes.
readWord64X4OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Word64X4##)#
Reads vector; offset in bytes.
readWord8X64OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Word8X64##)#
Reads vector; offset in bytes.
readWord16X32OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Word16X32##)#
Reads vector; offset in bytes.
readWord32X16OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Word32X16##)#
Reads vector; offset in bytes.
readWord64X8OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,Word64X8##)#
Reads vector; offset in bytes.
readFloatX4OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,FloatX4##)#
Reads vector; offset in bytes.
readDoubleX2OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,DoubleX2##)#
Reads vector; offset in bytes.
readFloatX8OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,FloatX8##)#
Reads vector; offset in bytes.
readDoubleX4OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,DoubleX4##)#
Reads vector; offset in bytes.
readFloatX16OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,FloatX16##)#
Reads vector; offset in bytes.
readDoubleX8OffAddr# ::Addr# ->Int# ->State# d -> (#State# d,DoubleX8##)#
Reads vector; offset in bytes.
writeInt16X16OffAddr# ::Addr# ->Int# ->Int16X16# ->State# d ->State# d#
Write vector; offset in bytes.
writeInt16X32OffAddr# ::Addr# ->Int# ->Int16X32# ->State# d ->State# d#
Write vector; offset in bytes.
writeInt32X16OffAddr# ::Addr# ->Int# ->Int32X16# ->State# d ->State# d#
Write vector; offset in bytes.
writeWord8X16OffAddr# ::Addr# ->Int# ->Word8X16# ->State# d ->State# d#
Write vector; offset in bytes.
writeWord16X8OffAddr# ::Addr# ->Int# ->Word16X8# ->State# d ->State# d#
Write vector; offset in bytes.
writeWord32X4OffAddr# ::Addr# ->Int# ->Word32X4# ->State# d ->State# d#
Write vector; offset in bytes.
writeWord64X2OffAddr# ::Addr# ->Int# ->Word64X2# ->State# d ->State# d#
Write vector; offset in bytes.
writeWord8X32OffAddr# ::Addr# ->Int# ->Word8X32# ->State# d ->State# d#
Write vector; offset in bytes.
writeWord16X16OffAddr# ::Addr# ->Int# ->Word16X16# ->State# d ->State# d#
Write vector; offset in bytes.
writeWord32X8OffAddr# ::Addr# ->Int# ->Word32X8# ->State# d ->State# d#
Write vector; offset in bytes.
writeWord64X4OffAddr# ::Addr# ->Int# ->Word64X4# ->State# d ->State# d#
Write vector; offset in bytes.
writeWord8X64OffAddr# ::Addr# ->Int# ->Word8X64# ->State# d ->State# d#
Write vector; offset in bytes.
writeWord16X32OffAddr# ::Addr# ->Int# ->Word16X32# ->State# d ->State# d#
Write vector; offset in bytes.
writeWord32X16OffAddr# ::Addr# ->Int# ->Word32X16# ->State# d ->State# d#
Write vector; offset in bytes.
writeWord64X8OffAddr# ::Addr# ->Int# ->Word64X8# ->State# d ->State# d#
Write vector; offset in bytes.
writeDoubleX2OffAddr# ::Addr# ->Int# ->DoubleX2# ->State# d ->State# d#
Write vector; offset in bytes.
writeDoubleX4OffAddr# ::Addr# ->Int# ->DoubleX4# ->State# d ->State# d#
Write vector; offset in bytes.
writeFloatX16OffAddr# ::Addr# ->Int# ->FloatX16# ->State# d ->State# d#
Write vector; offset in bytes.
writeDoubleX8OffAddr# ::Addr# ->Int# ->DoubleX8# ->State# d ->State# d#
Write vector; offset in bytes.
indexInt8ArrayAsInt8X16# ::ByteArray# ->Int# ->Int8X16##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexInt16ArrayAsInt16X8# ::ByteArray# ->Int# ->Int16X8##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexInt32ArrayAsInt32X4# ::ByteArray# ->Int# ->Int32X4##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexInt64ArrayAsInt64X2# ::ByteArray# ->Int# ->Int64X2##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexInt8ArrayAsInt8X32# ::ByteArray# ->Int# ->Int8X32##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexInt16ArrayAsInt16X16# ::ByteArray# ->Int# ->Int16X16##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexInt32ArrayAsInt32X8# ::ByteArray# ->Int# ->Int32X8##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexInt64ArrayAsInt64X4# ::ByteArray# ->Int# ->Int64X4##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexInt8ArrayAsInt8X64# ::ByteArray# ->Int# ->Int8X64##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexInt16ArrayAsInt16X32# ::ByteArray# ->Int# ->Int16X32##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexInt32ArrayAsInt32X16# ::ByteArray# ->Int# ->Int32X16##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexInt64ArrayAsInt64X8# ::ByteArray# ->Int# ->Int64X8##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexWord8ArrayAsWord8X16# ::ByteArray# ->Int# ->Word8X16##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexWord16ArrayAsWord16X8# ::ByteArray# ->Int# ->Word16X8##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexWord32ArrayAsWord32X4# ::ByteArray# ->Int# ->Word32X4##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexWord64ArrayAsWord64X2# ::ByteArray# ->Int# ->Word64X2##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexWord8ArrayAsWord8X32# ::ByteArray# ->Int# ->Word8X32##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexWord16ArrayAsWord16X16# ::ByteArray# ->Int# ->Word16X16##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexWord32ArrayAsWord32X8# ::ByteArray# ->Int# ->Word32X8##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexWord64ArrayAsWord64X4# ::ByteArray# ->Int# ->Word64X4##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexWord8ArrayAsWord8X64# ::ByteArray# ->Int# ->Word8X64##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexWord16ArrayAsWord16X32# ::ByteArray# ->Int# ->Word16X32##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexWord32ArrayAsWord32X16# ::ByteArray# ->Int# ->Word32X16##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexWord64ArrayAsWord64X8# ::ByteArray# ->Int# ->Word64X8##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexFloatArrayAsFloatX4# ::ByteArray# ->Int# ->FloatX4##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexDoubleArrayAsDoubleX2# ::ByteArray# ->Int# ->DoubleX2##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexFloatArrayAsFloatX8# ::ByteArray# ->Int# ->FloatX8##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexDoubleArrayAsDoubleX4# ::ByteArray# ->Int# ->DoubleX4##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexFloatArrayAsFloatX16# ::ByteArray# ->Int# ->FloatX16##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
indexDoubleArrayAsDoubleX8# ::ByteArray# ->Int# ->DoubleX8##
Read a vector from specified index of immutable array of scalars; offset is in scalar elements.
readInt8ArrayAsInt8X16# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int8X16##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readInt16ArrayAsInt16X8# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int16X8##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readInt32ArrayAsInt32X4# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int32X4##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readInt64ArrayAsInt64X2# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int64X2##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readInt8ArrayAsInt8X32# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int8X32##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readInt16ArrayAsInt16X16# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int16X16##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readInt32ArrayAsInt32X8# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int32X8##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readInt64ArrayAsInt64X4# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int64X4##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readInt8ArrayAsInt8X64# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int8X64##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readInt16ArrayAsInt16X32# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int16X32##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readInt32ArrayAsInt32X16# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int32X16##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readInt64ArrayAsInt64X8# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Int64X8##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readWord8ArrayAsWord8X16# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word8X16##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readWord16ArrayAsWord16X8# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word16X8##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readWord32ArrayAsWord32X4# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word32X4##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readWord64ArrayAsWord64X2# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word64X2##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readWord8ArrayAsWord8X32# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word8X32##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readWord16ArrayAsWord16X16# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word16X16##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readWord32ArrayAsWord32X8# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word32X8##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readWord64ArrayAsWord64X4# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word64X4##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readWord8ArrayAsWord8X64# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word8X64##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readWord16ArrayAsWord16X32# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word16X32##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readWord32ArrayAsWord32X16# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word32X16##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readWord64ArrayAsWord64X8# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,Word64X8##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readFloatArrayAsFloatX4# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,FloatX4##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readDoubleArrayAsDoubleX2# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,DoubleX2##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readFloatArrayAsFloatX8# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,FloatX8##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readDoubleArrayAsDoubleX4# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,DoubleX4##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readFloatArrayAsFloatX16# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,FloatX16##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
readDoubleArrayAsDoubleX8# ::MutableByteArray# d ->Int# ->State# d -> (#State# d,DoubleX8##)#
Read a vector from specified index of mutable array of scalars; offset is in scalar elements.
writeInt8ArrayAsInt8X16# ::MutableByteArray# d ->Int# ->Int8X16# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeInt16ArrayAsInt16X8# ::MutableByteArray# d ->Int# ->Int16X8# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeInt32ArrayAsInt32X4# ::MutableByteArray# d ->Int# ->Int32X4# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeInt64ArrayAsInt64X2# ::MutableByteArray# d ->Int# ->Int64X2# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeInt8ArrayAsInt8X32# ::MutableByteArray# d ->Int# ->Int8X32# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeInt16ArrayAsInt16X16# ::MutableByteArray# d ->Int# ->Int16X16# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeInt32ArrayAsInt32X8# ::MutableByteArray# d ->Int# ->Int32X8# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeInt64ArrayAsInt64X4# ::MutableByteArray# d ->Int# ->Int64X4# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeInt8ArrayAsInt8X64# ::MutableByteArray# d ->Int# ->Int8X64# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeInt16ArrayAsInt16X32# ::MutableByteArray# d ->Int# ->Int16X32# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeInt32ArrayAsInt32X16# ::MutableByteArray# d ->Int# ->Int32X16# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeInt64ArrayAsInt64X8# ::MutableByteArray# d ->Int# ->Int64X8# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeWord8ArrayAsWord8X16# ::MutableByteArray# d ->Int# ->Word8X16# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeWord16ArrayAsWord16X8# ::MutableByteArray# d ->Int# ->Word16X8# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeWord32ArrayAsWord32X4# ::MutableByteArray# d ->Int# ->Word32X4# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeWord64ArrayAsWord64X2# ::MutableByteArray# d ->Int# ->Word64X2# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeWord8ArrayAsWord8X32# ::MutableByteArray# d ->Int# ->Word8X32# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeWord16ArrayAsWord16X16# ::MutableByteArray# d ->Int# ->Word16X16# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeWord32ArrayAsWord32X8# ::MutableByteArray# d ->Int# ->Word32X8# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeWord64ArrayAsWord64X4# ::MutableByteArray# d ->Int# ->Word64X4# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeWord8ArrayAsWord8X64# ::MutableByteArray# d ->Int# ->Word8X64# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeWord16ArrayAsWord16X32# ::MutableByteArray# d ->Int# ->Word16X32# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeWord32ArrayAsWord32X16# ::MutableByteArray# d ->Int# ->Word32X16# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeWord64ArrayAsWord64X8# ::MutableByteArray# d ->Int# ->Word64X8# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeFloatArrayAsFloatX4# ::MutableByteArray# d ->Int# ->FloatX4# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeDoubleArrayAsDoubleX2# ::MutableByteArray# d ->Int# ->DoubleX2# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeFloatArrayAsFloatX8# ::MutableByteArray# d ->Int# ->FloatX8# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeDoubleArrayAsDoubleX4# ::MutableByteArray# d ->Int# ->DoubleX4# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeFloatArrayAsFloatX16# ::MutableByteArray# d ->Int# ->FloatX16# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
writeDoubleArrayAsDoubleX8# ::MutableByteArray# d ->Int# ->DoubleX8# ->State# d ->State# d#
Write a vector to specified index of mutable array of scalars; offset is in scalar elements.
indexInt8OffAddrAsInt8X16# ::Addr# ->Int# ->Int8X16##
Reads vector; offset in scalar elements.
indexInt16OffAddrAsInt16X8# ::Addr# ->Int# ->Int16X8##
Reads vector; offset in scalar elements.
indexInt32OffAddrAsInt32X4# ::Addr# ->Int# ->Int32X4##
Reads vector; offset in scalar elements.
indexInt64OffAddrAsInt64X2# ::Addr# ->Int# ->Int64X2##
Reads vector; offset in scalar elements.
indexInt8OffAddrAsInt8X32# ::Addr# ->Int# ->Int8X32##
Reads vector; offset in scalar elements.
indexInt16OffAddrAsInt16X16# ::Addr# ->Int# ->Int16X16##
Reads vector; offset in scalar elements.
indexInt32OffAddrAsInt32X8# ::Addr# ->Int# ->Int32X8##
Reads vector; offset in scalar elements.
indexInt64OffAddrAsInt64X4# ::Addr# ->Int# ->Int64X4##
Reads vector; offset in scalar elements.
indexInt8OffAddrAsInt8X64# ::Addr# ->Int# ->Int8X64##
Reads vector; offset in scalar elements.
indexInt16OffAddrAsInt16X32# ::Addr# ->Int# ->Int16X32##
Reads vector; offset in scalar elements.
indexInt32OffAddrAsInt32X16# ::Addr# ->Int# ->Int32X16##
Reads vector; offset in scalar elements.
indexInt64OffAddrAsInt64X8# ::Addr# ->Int# ->Int64X8##
Reads vector; offset in scalar elements.
indexWord8OffAddrAsWord8X16# ::Addr# ->Int# ->Word8X16##
Reads vector; offset in scalar elements.
indexWord16OffAddrAsWord16X8# ::Addr# ->Int# ->Word16X8##
Reads vector; offset in scalar elements.
indexWord32OffAddrAsWord32X4# ::Addr# ->Int# ->Word32X4##
Reads vector; offset in scalar elements.
indexWord64OffAddrAsWord64X2# ::Addr# ->Int# ->Word64X2##
Reads vector; offset in scalar elements.
indexWord8OffAddrAsWord8X32# ::Addr# ->Int# ->Word8X32##
Reads vector; offset in scalar elements.
indexWord16OffAddrAsWord16X16# ::Addr# ->Int# ->Word16X16##
Reads vector; offset in scalar elements.
indexWord32OffAddrAsWord32X8# ::Addr# ->Int# ->Word32X8##
Reads vector; offset in scalar elements.
indexWord64OffAddrAsWord64X4# ::Addr# ->Int# ->Word64X4##
Reads vector; offset in scalar elements.
indexWord8OffAddrAsWord8X64# ::Addr# ->Int# ->Word8X64##
Reads vector; offset in scalar elements.
indexWord16OffAddrAsWord16X32# ::Addr# ->Int# ->Word16X32##
Reads vector; offset in scalar elements.
indexWord32OffAddrAsWord32X16# ::Addr# ->Int# ->Word32X16##
Reads vector; offset in scalar elements.
indexWord64OffAddrAsWord64X8# ::Addr# ->Int# ->Word64X8##
Reads vector; offset in scalar elements.
indexFloatOffAddrAsFloatX4# ::Addr# ->Int# ->FloatX4##
Reads vector; offset in scalar elements.
indexDoubleOffAddrAsDoubleX2# ::Addr# ->Int# ->DoubleX2##
Reads vector; offset in scalar elements.
indexFloatOffAddrAsFloatX8# ::Addr# ->Int# ->FloatX8##
Reads vector; offset in scalar elements.
indexDoubleOffAddrAsDoubleX4# ::Addr# ->Int# ->DoubleX4##
Reads vector; offset in scalar elements.
indexFloatOffAddrAsFloatX16# ::Addr# ->Int# ->FloatX16##
Reads vector; offset in scalar elements.
indexDoubleOffAddrAsDoubleX8# ::Addr# ->Int# ->DoubleX8##
Reads vector; offset in scalar elements.
readInt8OffAddrAsInt8X16# ::Addr# ->Int# ->State# d -> (#State# d,Int8X16##)#
Reads vector; offset in scalar elements.
readInt16OffAddrAsInt16X8# ::Addr# ->Int# ->State# d -> (#State# d,Int16X8##)#
Reads vector; offset in scalar elements.
readInt32OffAddrAsInt32X4# ::Addr# ->Int# ->State# d -> (#State# d,Int32X4##)#
Reads vector; offset in scalar elements.
readInt64OffAddrAsInt64X2# ::Addr# ->Int# ->State# d -> (#State# d,Int64X2##)#
Reads vector; offset in scalar elements.
readInt8OffAddrAsInt8X32# ::Addr# ->Int# ->State# d -> (#State# d,Int8X32##)#
Reads vector; offset in scalar elements.
readInt16OffAddrAsInt16X16# ::Addr# ->Int# ->State# d -> (#State# d,Int16X16##)#
Reads vector; offset in scalar elements.
readInt32OffAddrAsInt32X8# ::Addr# ->Int# ->State# d -> (#State# d,Int32X8##)#
Reads vector; offset in scalar elements.
readInt64OffAddrAsInt64X4# ::Addr# ->Int# ->State# d -> (#State# d,Int64X4##)#
Reads vector; offset in scalar elements.
readInt8OffAddrAsInt8X64# ::Addr# ->Int# ->State# d -> (#State# d,Int8X64##)#
Reads vector; offset in scalar elements.
readInt16OffAddrAsInt16X32# ::Addr# ->Int# ->State# d -> (#State# d,Int16X32##)#
Reads vector; offset in scalar elements.
readInt32OffAddrAsInt32X16# ::Addr# ->Int# ->State# d -> (#State# d,Int32X16##)#
Reads vector; offset in scalar elements.
readInt64OffAddrAsInt64X8# ::Addr# ->Int# ->State# d -> (#State# d,Int64X8##)#
Reads vector; offset in scalar elements.
readWord8OffAddrAsWord8X16# ::Addr# ->Int# ->State# d -> (#State# d,Word8X16##)#
Reads vector; offset in scalar elements.
readWord16OffAddrAsWord16X8# ::Addr# ->Int# ->State# d -> (#State# d,Word16X8##)#
Reads vector; offset in scalar elements.
readWord32OffAddrAsWord32X4# ::Addr# ->Int# ->State# d -> (#State# d,Word32X4##)#
Reads vector; offset in scalar elements.
readWord64OffAddrAsWord64X2# ::Addr# ->Int# ->State# d -> (#State# d,Word64X2##)#
Reads vector; offset in scalar elements.
readWord8OffAddrAsWord8X32# ::Addr# ->Int# ->State# d -> (#State# d,Word8X32##)#
Reads vector; offset in scalar elements.
readWord16OffAddrAsWord16X16# ::Addr# ->Int# ->State# d -> (#State# d,Word16X16##)#
Reads vector; offset in scalar elements.
readWord32OffAddrAsWord32X8# ::Addr# ->Int# ->State# d -> (#State# d,Word32X8##)#
Reads vector; offset in scalar elements.
readWord64OffAddrAsWord64X4# ::Addr# ->Int# ->State# d -> (#State# d,Word64X4##)#
Reads vector; offset in scalar elements.
readWord8OffAddrAsWord8X64# ::Addr# ->Int# ->State# d -> (#State# d,Word8X64##)#
Reads vector; offset in scalar elements.
readWord16OffAddrAsWord16X32# ::Addr# ->Int# ->State# d -> (#State# d,Word16X32##)#
Reads vector; offset in scalar elements.
readWord32OffAddrAsWord32X16# ::Addr# ->Int# ->State# d -> (#State# d,Word32X16##)#
Reads vector; offset in scalar elements.
readWord64OffAddrAsWord64X8# ::Addr# ->Int# ->State# d -> (#State# d,Word64X8##)#
Reads vector; offset in scalar elements.
readFloatOffAddrAsFloatX4# ::Addr# ->Int# ->State# d -> (#State# d,FloatX4##)#
Reads vector; offset in scalar elements.
readDoubleOffAddrAsDoubleX2# ::Addr# ->Int# ->State# d -> (#State# d,DoubleX2##)#
Reads vector; offset in scalar elements.
readFloatOffAddrAsFloatX8# ::Addr# ->Int# ->State# d -> (#State# d,FloatX8##)#
Reads vector; offset in scalar elements.
readDoubleOffAddrAsDoubleX4# ::Addr# ->Int# ->State# d -> (#State# d,DoubleX4##)#
Reads vector; offset in scalar elements.
readFloatOffAddrAsFloatX16# ::Addr# ->Int# ->State# d -> (#State# d,FloatX16##)#
Reads vector; offset in scalar elements.
readDoubleOffAddrAsDoubleX8# ::Addr# ->Int# ->State# d -> (#State# d,DoubleX8##)#
Reads vector; offset in scalar elements.
writeInt8OffAddrAsInt8X16# ::Addr# ->Int# ->Int8X16# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeInt16OffAddrAsInt16X8# ::Addr# ->Int# ->Int16X8# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeInt32OffAddrAsInt32X4# ::Addr# ->Int# ->Int32X4# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeInt64OffAddrAsInt64X2# ::Addr# ->Int# ->Int64X2# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeInt8OffAddrAsInt8X32# ::Addr# ->Int# ->Int8X32# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeInt16OffAddrAsInt16X16# ::Addr# ->Int# ->Int16X16# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeInt32OffAddrAsInt32X8# ::Addr# ->Int# ->Int32X8# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeInt64OffAddrAsInt64X4# ::Addr# ->Int# ->Int64X4# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeInt8OffAddrAsInt8X64# ::Addr# ->Int# ->Int8X64# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeInt16OffAddrAsInt16X32# ::Addr# ->Int# ->Int16X32# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeInt32OffAddrAsInt32X16# ::Addr# ->Int# ->Int32X16# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeInt64OffAddrAsInt64X8# ::Addr# ->Int# ->Int64X8# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeWord8OffAddrAsWord8X16# ::Addr# ->Int# ->Word8X16# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeWord16OffAddrAsWord16X8# ::Addr# ->Int# ->Word16X8# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeWord32OffAddrAsWord32X4# ::Addr# ->Int# ->Word32X4# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeWord64OffAddrAsWord64X2# ::Addr# ->Int# ->Word64X2# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeWord8OffAddrAsWord8X32# ::Addr# ->Int# ->Word8X32# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeWord16OffAddrAsWord16X16# ::Addr# ->Int# ->Word16X16# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeWord32OffAddrAsWord32X8# ::Addr# ->Int# ->Word32X8# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeWord64OffAddrAsWord64X4# ::Addr# ->Int# ->Word64X4# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeWord8OffAddrAsWord8X64# ::Addr# ->Int# ->Word8X64# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeWord16OffAddrAsWord16X32# ::Addr# ->Int# ->Word16X32# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeWord32OffAddrAsWord32X16# ::Addr# ->Int# ->Word32X16# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeWord64OffAddrAsWord64X8# ::Addr# ->Int# ->Word64X8# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeFloatOffAddrAsFloatX4# ::Addr# ->Int# ->FloatX4# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeDoubleOffAddrAsDoubleX2# ::Addr# ->Int# ->DoubleX2# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeFloatOffAddrAsFloatX8# ::Addr# ->Int# ->FloatX8# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeDoubleOffAddrAsDoubleX4# ::Addr# ->Int# ->DoubleX4# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeFloatOffAddrAsFloatX16# ::Addr# ->Int# ->FloatX16# ->State# d ->State# d#
Write vector; offset in scalar elements.
writeDoubleOffAddrAsDoubleX8# ::Addr# ->Int# ->DoubleX8# ->State# d ->State# d#
Write vector; offset in scalar elements.
prefetchByteArray3# ::ByteArray# ->Int# ->State# d ->State# d#
prefetchMutableByteArray3# ::MutableByteArray# d ->Int# ->State# d ->State# d#
prefetchValue3# :: a ->State# d ->State# d#
prefetchByteArray2# ::ByteArray# ->Int# ->State# d ->State# d#
prefetchMutableByteArray2# ::MutableByteArray# d ->Int# ->State# d ->State# d#
prefetchValue2# :: a ->State# d ->State# d#
prefetchByteArray1# ::ByteArray# ->Int# ->State# d ->State# d#
prefetchMutableByteArray1# ::MutableByteArray# d ->Int# ->State# d ->State# d#
prefetchValue1# :: a ->State# d ->State# d#
prefetchByteArray0# ::ByteArray# ->Int# ->State# d ->State# d#
prefetchMutableByteArray0# ::MutableByteArray# d ->Int# ->State# d ->State# d#
prefetchValue0# :: a ->State# d ->State# d#
shiftL# ::Word# ->Int# ->Word#Source#
Shift the argument left by the specified number of bits (which must be non-negative).
shiftRL# ::Word# ->Int# ->Word#Source#
Shift the argument right by the specified number of bits (which must be non-negative). TheRL means "right, logical" (as opposed to RA for arithmetic) (although an arithmetic right shift wouldn't make sense for Word#)
iShiftL# ::Int# ->Int# ->Int#Source#
Shift the argument left by the specified number of bits (which must be non-negative).
iShiftRA# ::Int# ->Int# ->Int#Source#
Shift the argument right (signed) by the specified number of bits (which must be non-negative). TheRA means "right, arithmetic" (as opposed to RL for logical)
iShiftRL# ::Int# ->Int# ->Int#Source#
Shift the argument right (unsigned) by the specified number of bits (which must be non-negative). TheRL means "right, logical" (as opposed to RA for arithmetic)
Alias fortagToEnum#. Returns True if its parameter is 1# and False if it is 0#.
Class for string-like datastructures; used by the overloaded string extension (-XOverloadedStrings in GHC).
Methods
fromString ::String -> aSource#
breakpoint :: a -> aSource#
breakpointCond ::Bool -> a -> aSource#
Thelazy function restrains strictness analysis a little. The calllazy e means the same ase, butlazy has a magical property so far as strictness analysis is concerned: it is lazy in its first argument, even though its semantics is strict. After strictness analysis has run, calls tolazy are inlined to be the identity function.
This behaviour is occasionally useful when controlling evaluation order. Notably,lazy is used in the library definition ofpar:
par :: a -> b -> bpar x y = case (par# x) of _ -> lazy y
Iflazy were not lazy,par would look strict iny which would defeat the whole purpose ofpar.
The callinline f arranges thatf is inlined, regardless of its size. More precisely, the callinline f rewrites to the right-hand side off's definition. This allows the programmer to control inlining from a particular call site rather than the definition site of the function (c.f.INLINE pragmas).
This inlining occurs regardless of the argument to the call or the size off's definition; it is unconditional. The main caveat is thatf's definition must be visible to the compiler; it is therefore recommended to mark the function with anINLINABLE pragma at its definition so that GHC guarantees to record its unfolding regardless of size.
If no inlining takes place, theinline function expands to the identity function in Phase zero, so its use imposes no overhead.
oneShot :: (a -> b) -> a -> b#
TheoneShot function can be used to give a hint to the compiler that its argument will be called at most once, which may (or may not) enable certain optimizations. It can be useful to improve the performance of code in continuation passing style.
IfoneShot is used wrongly, then it may be that computations whose result that would otherwise be shared are re-evaluated every time they are used. Otherwise, the use ofoneShot is safe.
oneShot is representation polymorphic: the type variables may refer to lifted or unlifted types.
RealWorld state transformersrunRW# :: (State#RealWorld -> o) -> o#
Apply a function to a 'State# RealWorld' token. When manually applying a function torealWorld#, it is necessary to useNOINLINE to prevent semantically undesirable floating.runRW# is inlined, but only very late in compilation after all floating is complete.
These are available from theTrustworthy moduleData.Coerce as well
Since: 4.7.0.0
coerce ::Coercible a b => a -> b#
The functioncoerce allows you to safely convert between values of types that have the same representation with no run-time overhead. In the simplest case you can use it instead of a newtype constructor, to go from the newtype's concrete type to the abstract type. But it also works in more complicated settings, e.g. converting a list of newtypes to a list of concrete types.
class a ~R# b =>Coercible (a :: k0) (b :: k0)#
Coercible is a two-parameter class that has instances for typesa andb if the compiler can infer that they have the same representation. This class does not have regular instances; instead they are created on-the-fly during type-checking. Trying to manually declare an instance ofCoercible is an error.
Nevertheless one can pretend that the following three kinds of instances exist. First, as a trivial base-case:
instance Coercible a a
Furthermore, for every type constructor there is an instance that allows to coerce under the type constructor. For example, letD be a prototypical type constructor (data ornewtype) with three type arguments, which have rolesnominal,representational resp.phantom. Then there is an instance of the form
instance Coercible b b' => Coercible (D a b c) (D a b' c')
Note that thenominal type arguments are equal, therepresentational type arguments can differ, but need to have aCoercible instance themself, and thephantom type arguments can be changed arbitrarily.
The third kind of instance exists for everynewtype NT = MkNT T and comes in two variants, namely
instance Coercible a T => Coercible a NT
instance Coercible T b => Coercible NT b
This instance is only usable if the constructorMkNT is in scope.
If, as a library author of a type constructor likeSet a, you want to prevent a user of your module to writecoerce :: Set T -> Set NT, you need to set the role ofSet's type parameter tonominal, by writing
type role Set nominal
For more details about this feature, please refer toSafe Coercions by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich.
Since: ghc-prim-4.7.0.0
class a ~# b => (a :: k0)~~ (b :: k1)#
Lifted, heterogeneous equality. By lifted, we mean that it can be bogus (deferred type error). By heterogeneous, the two typesa andb might have different kinds. Because~~ can appear unexpectedly in error messages to users who do not care about the difference between heterogeneous equality~~ and homogeneous equality~, this is printed as~ unless-fprint-equality-relations is set.
dataTYPE (a ::RuntimeRep) ::RuntimeRep ->Type#
| Functor f =>Generic1 (f:.: g :: k ->Type)Source# | |
| Functor f =>Generic1 (Compose f g :: k ->Type)Source# | |
| Monad (U1 ::Type ->Type)Source# | Since: 4.9.0.0 |
| Monad (Proxy ::Type ->Type)Source# | Since: 4.7.0.0 |
| Functor (V1 ::Type ->Type)Source# | Since: 4.9.0.0 |
| Functor (U1 ::Type ->Type)Source# | Since: 4.9.0.0 |
| Functor (Proxy ::Type ->Type)Source# | Since: 4.7.0.0 |
| Applicative (U1 ::Type ->Type)Source# | Since: 4.9.0.0 |
| Applicative (Proxy ::Type ->Type)Source# | Since: 4.7.0.0 |
| Foldable (V1 ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>V1 m -> mSource# foldMap ::Monoid m => (a -> m) ->V1 a -> mSource# foldr :: (a -> b -> b) -> b ->V1 a -> bSource# foldr' :: (a -> b -> b) -> b ->V1 a -> bSource# foldl :: (b -> a -> b) -> b ->V1 a -> bSource# foldl' :: (b -> a -> b) -> b ->V1 a -> bSource# foldr1 :: (a -> a -> a) ->V1 a -> aSource# foldl1 :: (a -> a -> a) ->V1 a -> aSource# elem ::Eq a => a ->V1 a ->BoolSource# maximum ::Ord a =>V1 a -> aSource# minimum ::Ord a =>V1 a -> aSource# | |
| Foldable (U1 ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>U1 m -> mSource# foldMap ::Monoid m => (a -> m) ->U1 a -> mSource# foldr :: (a -> b -> b) -> b ->U1 a -> bSource# foldr' :: (a -> b -> b) -> b ->U1 a -> bSource# foldl :: (b -> a -> b) -> b ->U1 a -> bSource# foldl' :: (b -> a -> b) -> b ->U1 a -> bSource# foldr1 :: (a -> a -> a) ->U1 a -> aSource# foldl1 :: (a -> a -> a) ->U1 a -> aSource# elem ::Eq a => a ->U1 a ->BoolSource# maximum ::Ord a =>U1 a -> aSource# minimum ::Ord a =>U1 a -> aSource# | |
| Foldable (Proxy ::Type ->Type)Source# | Since: 4.7.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>Proxy m -> mSource# foldMap ::Monoid m => (a -> m) ->Proxy a -> mSource# foldr :: (a -> b -> b) -> b ->Proxy a -> bSource# foldr' :: (a -> b -> b) -> b ->Proxy a -> bSource# foldl :: (b -> a -> b) -> b ->Proxy a -> bSource# foldl' :: (b -> a -> b) -> b ->Proxy a -> bSource# foldr1 :: (a -> a -> a) ->Proxy a -> aSource# foldl1 :: (a -> a -> a) ->Proxy a -> aSource# toList ::Proxy a -> [a]Source# elem ::Eq a => a ->Proxy a ->BoolSource# maximum ::Ord a =>Proxy a -> aSource# minimum ::Ord a =>Proxy a -> aSource# | |
| Traversable (V1 ::Type ->Type)Source# | Since: 4.9.0.0 |
| Traversable (U1 ::Type ->Type)Source# | Since: 4.9.0.0 |
| Traversable (Proxy ::Type ->Type)Source# | Since: 4.7.0.0 |
| MonadPlus (U1 ::Type ->Type)Source# | Since: 4.9.0.0 |
| MonadPlus (Proxy ::Type ->Type)Source# | Since: 4.9.0.0 |
| Alternative (U1 ::Type ->Type)Source# | Since: 4.9.0.0 |
| Alternative (Proxy ::Type ->Type)Source# | Since: 4.9.0.0 |
| MonadZip (U1 ::Type ->Type)Source# | Since: 4.9.0.0 |
| MonadZip (Proxy ::Type ->Type)Source# | Since: 4.9.0.0 |
| Show2 (Const ::Type ->Type ->Type)Source# | Since: 4.9.0.0 |
| Read2 (Const ::Type ->Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Classes Methods liftReadsPrec2 :: (Int ->ReadS a) ->ReadS [a] -> (Int ->ReadS b) ->ReadS [b] ->Int ->ReadS (Const a b)Source# liftReadList2 :: (Int ->ReadS a) ->ReadS [a] -> (Int ->ReadS b) ->ReadS [b] ->ReadS [Const a b]Source# liftReadPrec2 ::ReadPrec a ->ReadPrec [a] ->ReadPrec b ->ReadPrec [b] ->ReadPrec (Const a b)Source# liftReadListPrec2 ::ReadPrec a ->ReadPrec [a] ->ReadPrec b ->ReadPrec [b] ->ReadPrec [Const a b]Source# | |
| Ord2 (Const ::Type ->Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Classes | |
| Eq2 (Const ::Type ->Type ->Type)Source# | Since: 4.9.0.0 |
| Show1 (Proxy ::Type ->Type)Source# | Since: 4.9.0.0 |
| Read1 (Proxy ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Classes | |
| Ord1 (Proxy ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Classes | |
| Eq1 (Proxy ::Type ->Type)Source# | Since: 4.9.0.0 |
| Bifunctor (Const ::Type ->Type ->Type)Source# | Since: 4.8.0.0 |
| Bifoldable (Const ::Type ->Type ->Type)Source# | Since: 4.10.0.0 |
| Bitraversable (Const ::Type ->Type ->Type)Source# | Since: 4.10.0.0 |
Instance detailsDefined inData.Bitraversable Methods bitraverse ::Applicative f => (a -> f c) -> (b -> f d) ->Const a b -> f (Const c d)Source# | |
| Contravariant (V1 ::Type ->Type)Source# | |
| Contravariant (U1 ::Type ->Type)Source# | |
| Contravariant (Proxy ::Type ->Type)Source# | |
| Generic1 []Source# | |
| Generic1MaybeSource# | |
| Generic1Par1Source# | |
| Generic1NonEmptySource# | |
| Generic1DownSource# | |
| Generic1ProductSource# | |
| Generic1SumSource# | |
| Generic1DualSource# | |
| Generic1LastSource# | |
| Generic1FirstSource# | |
| Generic1IdentitySource# | |
| Generic1ZipListSource# | |
| Generic1OptionSource# | |
| Generic1WrappedMonoidSource# | |
Instance detailsDefined inData.Semigroup Associated Types typeRep1WrappedMonoid :: k ->TypeSource# Methods from1 ::WrappedMonoid a ->Rep1WrappedMonoid aSource# to1 ::Rep1WrappedMonoid a ->WrappedMonoid aSource# | |
| Generic1LastSource# | |
| Generic1FirstSource# | |
| Generic1MaxSource# | |
| Generic1MinSource# | |
| Generic1ComplexSource# | |
| CategoryOpSource# | |
| Generic1 (Either a ::Type ->Type)Source# | |
| Generic1 ((,) a ::Type ->Type)Source# | |
| Generic1 (WrappedMonad m ::Type ->Type)Source# | |
Instance detailsDefined inControl.Applicative Associated Types typeRep1 (WrappedMonad m) :: k ->TypeSource# Methods from1 ::WrappedMonad m a ->Rep1 (WrappedMonad m) aSource# to1 ::Rep1 (WrappedMonad m) a ->WrappedMonad m aSource# | |
| Generic1 (Arg a ::Type ->Type)Source# | |
| Monad m =>Category (Kleisli m ::Type ->Type ->Type)Source# | Since: 3.0 |
| Generic1 ((,,) a b ::Type ->Type)Source# | |
| Generic1 (WrappedArrow a b ::Type ->Type)Source# | |
Instance detailsDefined inControl.Applicative Associated Types typeRep1 (WrappedArrow a b) :: k ->TypeSource# Methods from1 ::WrappedArrow a b a0 ->Rep1 (WrappedArrow a b) a0Source# to1 ::Rep1 (WrappedArrow a b) a0 ->WrappedArrow a b a0Source# | |
| Category ((->) ::Type ->Type ->Type)Source# | Since: 3.0 |
| Generic1 ((,,,) a b c ::Type ->Type)Source# | |
| Generic1 ((,,,,) a b c d ::Type ->Type)Source# | |
| Generic1 ((,,,,,) a b c d e ::Type ->Type)Source# | |
| Generic1 ((,,,,,,) a b c d e f ::Type ->Type)Source# | |
| Monad f =>Monad (Rec1 f)Source# | Since: 4.9.0.0 |
| Monad f =>Monad (Alt f)Source# | Since: 4.8.0.0 |
| Monad f =>Monad (Ap f)Source# | Since: 4.12.0.0 |
| Data p =>Data (V1 p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->V1 p -> c (V1 p)Source# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (V1 p)Source# toConstr ::V1 p ->ConstrSource# dataTypeOf ::V1 p ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (V1 p))Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (V1 p))Source# gmapT :: (forall b.Data b => b -> b) ->V1 p ->V1 pSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->V1 p -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->V1 p -> rSource# gmapQ :: (forall d.Data d => d -> u) ->V1 p -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->V1 p -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->V1 p -> m (V1 p)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->V1 p -> m (V1 p)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->V1 p -> m (V1 p)Source# | |
| Data p =>Data (U1 p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->U1 p -> c (U1 p)Source# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (U1 p)Source# toConstr ::U1 p ->ConstrSource# dataTypeOf ::U1 p ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (U1 p))Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (U1 p))Source# gmapT :: (forall b.Data b => b -> b) ->U1 p ->U1 pSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->U1 p -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->U1 p -> rSource# gmapQ :: (forall d.Data d => d -> u) ->U1 p -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->U1 p -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->U1 p -> m (U1 p)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->U1 p -> m (U1 p)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->U1 p -> m (U1 p)Source# | |
| Data t =>Data (Proxy t)Source# | Since: 4.7.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Proxy t -> c (Proxy t)Source# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (Proxy t)Source# toConstr ::Proxy t ->ConstrSource# dataTypeOf ::Proxy t ->DataTypeSource# dataCast1 ::Typeable t0 => (forall d.Data d => c (t0 d)) ->Maybe (c (Proxy t))Source# dataCast2 ::Typeable t0 => (forall d e. (Data d,Data e) => c (t0 d e)) ->Maybe (c (Proxy t))Source# gmapT :: (forall b.Data b => b -> b) ->Proxy t ->Proxy tSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Proxy t -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Proxy t -> rSource# gmapQ :: (forall d.Data d => d -> u) ->Proxy t -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->Proxy t -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->Proxy t -> m (Proxy t)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Proxy t -> m (Proxy t)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Proxy t -> m (Proxy t)Source# | |
| Functor f =>Functor (Rec1 f)Source# | Since: 4.9.0.0 |
| Functor (URecChar ::Type ->Type)Source# | Since: 4.9.0.0 |
| Functor (URecDouble ::Type ->Type)Source# | Since: 4.9.0.0 |
| Functor (URecFloat ::Type ->Type)Source# | Since: 4.9.0.0 |
| Functor (URecInt ::Type ->Type)Source# | Since: 4.9.0.0 |
| Functor (URecWord ::Type ->Type)Source# | Since: 4.9.0.0 |
| Functor (URec (Ptr ()) ::Type ->Type)Source# | Since: 4.9.0.0 |
| Functor f =>Functor (Alt f)Source# | Since: 4.8.0.0 |
| Functor f =>Functor (Ap f)Source# | Since: 4.12.0.0 |
| Functor (Const m ::Type ->Type)Source# | Since: 2.1 |
| MonadFix f =>MonadFix (Rec1 f)Source# | Since: 4.9.0.0 |
| MonadFix f =>MonadFix (Alt f)Source# | Since: 4.8.0.0 |
| MonadFix f =>MonadFix (Ap f)Source# | Since: 4.12.0.0 |
| MonadFail f =>MonadFail (Ap f)Source# | Since: 4.12.0.0 |
| Applicative f =>Applicative (Rec1 f)Source# | Since: 4.9.0.0 |
| Applicative f =>Applicative (Alt f)Source# | Since: 4.8.0.0 |
| Applicative f =>Applicative (Ap f)Source# | Since: 4.12.0.0 |
| Monoid m =>Applicative (Const m ::Type ->Type)Source# | Since: 2.0.1 |
| Foldable f =>Foldable (Rec1 f)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>Rec1 f m -> mSource# foldMap ::Monoid m => (a -> m) ->Rec1 f a -> mSource# foldr :: (a -> b -> b) -> b ->Rec1 f a -> bSource# foldr' :: (a -> b -> b) -> b ->Rec1 f a -> bSource# foldl :: (b -> a -> b) -> b ->Rec1 f a -> bSource# foldl' :: (b -> a -> b) -> b ->Rec1 f a -> bSource# foldr1 :: (a -> a -> a) ->Rec1 f a -> aSource# foldl1 :: (a -> a -> a) ->Rec1 f a -> aSource# toList ::Rec1 f a -> [a]Source# length ::Rec1 f a ->IntSource# elem ::Eq a => a ->Rec1 f a ->BoolSource# maximum ::Ord a =>Rec1 f a -> aSource# minimum ::Ord a =>Rec1 f a -> aSource# | |
| Foldable (URecChar ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>URecChar m -> mSource# foldMap ::Monoid m => (a -> m) ->URecChar a -> mSource# foldr :: (a -> b -> b) -> b ->URecChar a -> bSource# foldr' :: (a -> b -> b) -> b ->URecChar a -> bSource# foldl :: (b -> a -> b) -> b ->URecChar a -> bSource# foldl' :: (b -> a -> b) -> b ->URecChar a -> bSource# foldr1 :: (a -> a -> a) ->URecChar a -> aSource# foldl1 :: (a -> a -> a) ->URecChar a -> aSource# toList ::URecChar a -> [a]Source# null ::URecChar a ->BoolSource# length ::URecChar a ->IntSource# elem ::Eq a => a ->URecChar a ->BoolSource# maximum ::Ord a =>URecChar a -> aSource# minimum ::Ord a =>URecChar a -> aSource# | |
| Foldable (URecDouble ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>URecDouble m -> mSource# foldMap ::Monoid m => (a -> m) ->URecDouble a -> mSource# foldr :: (a -> b -> b) -> b ->URecDouble a -> bSource# foldr' :: (a -> b -> b) -> b ->URecDouble a -> bSource# foldl :: (b -> a -> b) -> b ->URecDouble a -> bSource# foldl' :: (b -> a -> b) -> b ->URecDouble a -> bSource# foldr1 :: (a -> a -> a) ->URecDouble a -> aSource# foldl1 :: (a -> a -> a) ->URecDouble a -> aSource# toList ::URecDouble a -> [a]Source# null ::URecDouble a ->BoolSource# length ::URecDouble a ->IntSource# elem ::Eq a => a ->URecDouble a ->BoolSource# maximum ::Ord a =>URecDouble a -> aSource# minimum ::Ord a =>URecDouble a -> aSource# | |
| Foldable (URecFloat ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>URecFloat m -> mSource# foldMap ::Monoid m => (a -> m) ->URecFloat a -> mSource# foldr :: (a -> b -> b) -> b ->URecFloat a -> bSource# foldr' :: (a -> b -> b) -> b ->URecFloat a -> bSource# foldl :: (b -> a -> b) -> b ->URecFloat a -> bSource# foldl' :: (b -> a -> b) -> b ->URecFloat a -> bSource# foldr1 :: (a -> a -> a) ->URecFloat a -> aSource# foldl1 :: (a -> a -> a) ->URecFloat a -> aSource# toList ::URecFloat a -> [a]Source# null ::URecFloat a ->BoolSource# length ::URecFloat a ->IntSource# elem ::Eq a => a ->URecFloat a ->BoolSource# maximum ::Ord a =>URecFloat a -> aSource# minimum ::Ord a =>URecFloat a -> aSource# | |
| Foldable (URecInt ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>URecInt m -> mSource# foldMap ::Monoid m => (a -> m) ->URecInt a -> mSource# foldr :: (a -> b -> b) -> b ->URecInt a -> bSource# foldr' :: (a -> b -> b) -> b ->URecInt a -> bSource# foldl :: (b -> a -> b) -> b ->URecInt a -> bSource# foldl' :: (b -> a -> b) -> b ->URecInt a -> bSource# foldr1 :: (a -> a -> a) ->URecInt a -> aSource# foldl1 :: (a -> a -> a) ->URecInt a -> aSource# toList ::URecInt a -> [a]Source# null ::URecInt a ->BoolSource# length ::URecInt a ->IntSource# elem ::Eq a => a ->URecInt a ->BoolSource# maximum ::Ord a =>URecInt a -> aSource# minimum ::Ord a =>URecInt a -> aSource# | |
| Foldable (URecWord ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>URecWord m -> mSource# foldMap ::Monoid m => (a -> m) ->URecWord a -> mSource# foldr :: (a -> b -> b) -> b ->URecWord a -> bSource# foldr' :: (a -> b -> b) -> b ->URecWord a -> bSource# foldl :: (b -> a -> b) -> b ->URecWord a -> bSource# foldl' :: (b -> a -> b) -> b ->URecWord a -> bSource# foldr1 :: (a -> a -> a) ->URecWord a -> aSource# foldl1 :: (a -> a -> a) ->URecWord a -> aSource# toList ::URecWord a -> [a]Source# null ::URecWord a ->BoolSource# length ::URecWord a ->IntSource# elem ::Eq a => a ->URecWord a ->BoolSource# maximum ::Ord a =>URecWord a -> aSource# minimum ::Ord a =>URecWord a -> aSource# | |
| Foldable (URec (Ptr ()) ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>URec (Ptr ()) m -> mSource# foldMap ::Monoid m => (a -> m) ->URec (Ptr ()) a -> mSource# foldr :: (a -> b -> b) -> b ->URec (Ptr ()) a -> bSource# foldr' :: (a -> b -> b) -> b ->URec (Ptr ()) a -> bSource# foldl :: (b -> a -> b) -> b ->URec (Ptr ()) a -> bSource# foldl' :: (b -> a -> b) -> b ->URec (Ptr ()) a -> bSource# foldr1 :: (a -> a -> a) ->URec (Ptr ()) a -> aSource# foldl1 :: (a -> a -> a) ->URec (Ptr ()) a -> aSource# toList ::URec (Ptr ()) a -> [a]Source# null ::URec (Ptr ()) a ->BoolSource# length ::URec (Ptr ()) a ->IntSource# elem ::Eq a => a ->URec (Ptr ()) a ->BoolSource# maximum ::Ord a =>URec (Ptr ()) a -> aSource# minimum ::Ord a =>URec (Ptr ()) a -> aSource# | |
| Foldable f =>Foldable (Alt f)Source# | Since: 4.12.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>Alt f m -> mSource# foldMap ::Monoid m => (a -> m) ->Alt f a -> mSource# foldr :: (a -> b -> b) -> b ->Alt f a -> bSource# foldr' :: (a -> b -> b) -> b ->Alt f a -> bSource# foldl :: (b -> a -> b) -> b ->Alt f a -> bSource# foldl' :: (b -> a -> b) -> b ->Alt f a -> bSource# foldr1 :: (a -> a -> a) ->Alt f a -> aSource# foldl1 :: (a -> a -> a) ->Alt f a -> aSource# toList ::Alt f a -> [a]Source# elem ::Eq a => a ->Alt f a ->BoolSource# maximum ::Ord a =>Alt f a -> aSource# minimum ::Ord a =>Alt f a -> aSource# | |
| Foldable f =>Foldable (Ap f)Source# | Since: 4.12.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>Ap f m -> mSource# foldMap ::Monoid m => (a -> m) ->Ap f a -> mSource# foldr :: (a -> b -> b) -> b ->Ap f a -> bSource# foldr' :: (a -> b -> b) -> b ->Ap f a -> bSource# foldl :: (b -> a -> b) -> b ->Ap f a -> bSource# foldl' :: (b -> a -> b) -> b ->Ap f a -> bSource# foldr1 :: (a -> a -> a) ->Ap f a -> aSource# foldl1 :: (a -> a -> a) ->Ap f a -> aSource# elem ::Eq a => a ->Ap f a ->BoolSource# maximum ::Ord a =>Ap f a -> aSource# minimum ::Ord a =>Ap f a -> aSource# | |
| Foldable (Const m ::Type ->Type)Source# | Since: 4.7.0.0 |
Instance detailsDefined inData.Functor.Const Methods fold ::Monoid m0 =>Const m m0 -> m0Source# foldMap ::Monoid m0 => (a -> m0) ->Const m a -> m0Source# foldr :: (a -> b -> b) -> b ->Const m a -> bSource# foldr' :: (a -> b -> b) -> b ->Const m a -> bSource# foldl :: (b -> a -> b) -> b ->Const m a -> bSource# foldl' :: (b -> a -> b) -> b ->Const m a -> bSource# foldr1 :: (a -> a -> a) ->Const m a -> aSource# foldl1 :: (a -> a -> a) ->Const m a -> aSource# toList ::Const m a -> [a]Source# null ::Const m a ->BoolSource# length ::Const m a ->IntSource# elem ::Eq a => a ->Const m a ->BoolSource# maximum ::Ord a =>Const m a -> aSource# minimum ::Ord a =>Const m a -> aSource# | |
| Traversable f =>Traversable (Rec1 f)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| Traversable (URecChar ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| Traversable (URecDouble ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| Traversable (URecFloat ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| Traversable (URecInt ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| Traversable (URecWord ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| Traversable (URec (Ptr ()) ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable Methods traverse ::Applicative f => (a -> f b) ->URec (Ptr ()) a -> f (URec (Ptr ()) b)Source# sequenceA ::Applicative f =>URec (Ptr ()) (f a) -> f (URec (Ptr ()) a)Source# mapM ::Monad m => (a -> m b) ->URec (Ptr ()) a -> m (URec (Ptr ()) b)Source# sequence ::Monad m =>URec (Ptr ()) (m a) -> m (URec (Ptr ()) a)Source# | |
| Traversable f =>Traversable (Alt f)Source# | Since: 4.12.0.0 |
Instance detailsDefined inData.Traversable | |
| Traversable f =>Traversable (Ap f)Source# | Since: 4.12.0.0 |
| Traversable (Const m ::Type ->Type)Source# | Since: 4.7.0.0 |
Instance detailsDefined inData.Traversable | |
| MonadPlus f =>MonadPlus (Rec1 f)Source# | Since: 4.9.0.0 |
| MonadPlus f =>MonadPlus (Alt f)Source# | Since: 4.8.0.0 |
| MonadPlus f =>MonadPlus (Ap f)Source# | Since: 4.12.0.0 |
| Alternative f =>Alternative (Rec1 f)Source# | Since: 4.9.0.0 |
| Alternative f =>Alternative (Alt f)Source# | Since: 4.8.0.0 |
| Alternative f =>Alternative (Ap f)Source# | Since: 4.12.0.0 |
| MonadZip f =>MonadZip (Rec1 f)Source# | Since: 4.9.0.0 |
| MonadZip f =>MonadZip (Alt f)Source# | Since: 4.8.0.0 |
| Show a =>Show1 (Const a ::Type ->Type)Source# | Since: 4.9.0.0 |
| Read a =>Read1 (Const a ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Classes Methods liftReadsPrec :: (Int ->ReadS a0) ->ReadS [a0] ->Int ->ReadS (Const a a0)Source# liftReadList :: (Int ->ReadS a0) ->ReadS [a0] ->ReadS [Const a a0]Source# liftReadPrec ::ReadPrec a0 ->ReadPrec [a0] ->ReadPrec (Const a a0)Source# liftReadListPrec ::ReadPrec a0 ->ReadPrec [a0] ->ReadPrec [Const a a0]Source# | |
| Ord a =>Ord1 (Const a ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Classes | |
| Eq a =>Eq1 (Const a ::Type ->Type)Source# | Since: 4.9.0.0 |
| Bifunctor (K1 i ::Type ->Type ->Type)Source# | Since: 4.9.0.0 |
| Bifoldable (K1 i ::Type ->Type ->Type)Source# | Since: 4.10.0.0 |
| Bitraversable (K1 i ::Type ->Type ->Type)Source# | Since: 4.10.0.0 |
Instance detailsDefined inData.Bitraversable Methods bitraverse ::Applicative f => (a -> f c) -> (b -> f d) ->K1 i a b -> f (K1 i c d)Source# | |
| Contravariant f =>Contravariant (Rec1 f)Source# | |
| Contravariant f =>Contravariant (Alt f)Source# | |
| Contravariant (Const a ::Type ->Type)Source# | |
| (Applicative f,Bounded a) =>Bounded (Ap f a)Source# | Since: 4.12.0.0 |
| (Monad f,Monad g) =>Monad (f:*: g)Source# | Since: 4.9.0.0 |
| (Monad f,Monad g) =>Monad (Product f g)Source# | Since: 4.9.0.0 |
| (Data (f p),Typeable f,Data p) =>Data (Rec1 f p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Rec1 f p -> c (Rec1 f p)Source# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (Rec1 f p)Source# toConstr ::Rec1 f p ->ConstrSource# dataTypeOf ::Rec1 f p ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (Rec1 f p))Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (Rec1 f p))Source# gmapT :: (forall b.Data b => b -> b) ->Rec1 f p ->Rec1 f pSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Rec1 f p -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Rec1 f p -> rSource# gmapQ :: (forall d.Data d => d -> u) ->Rec1 f p -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->Rec1 f p -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->Rec1 f p -> m (Rec1 f p)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Rec1 f p -> m (Rec1 f p)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Rec1 f p -> m (Rec1 f p)Source# | |
| (a ~ b,Data a) =>Data (a:~: b)Source# | Since: 4.7.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b0.Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a:~: b) -> c (a:~: b)Source# gunfold :: (forall b0 r.Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (a:~: b)Source# toConstr :: (a:~: b) ->ConstrSource# dataTypeOf :: (a:~: b) ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (a:~: b))Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (a:~: b))Source# gmapT :: (forall b0.Data b0 => b0 -> b0) -> (a:~: b) -> a:~: bSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') -> (a:~: b) -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') -> (a:~: b) -> rSource# gmapQ :: (forall d.Data d => d -> u) -> (a:~: b) -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) -> (a:~: b) -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) -> (a:~: b) -> m (a:~: b)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) -> (a:~: b) -> m (a:~: b)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) -> (a:~: b) -> m (a:~: b)Source# | |
| (Coercible a b,Data a,Data b) =>Data (Coercion a b)Source# | Since: 4.7.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b0.Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) ->Coercion a b -> c (Coercion a b)Source# gunfold :: (forall b0 r.Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (Coercion a b)Source# toConstr ::Coercion a b ->ConstrSource# dataTypeOf ::Coercion a b ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (Coercion a b))Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (Coercion a b))Source# gmapT :: (forall b0.Data b0 => b0 -> b0) ->Coercion a b ->Coercion a bSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Coercion a b -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Coercion a b -> rSource# gmapQ :: (forall d.Data d => d -> u) ->Coercion a b -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->Coercion a b -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->Coercion a b -> m (Coercion a b)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Coercion a b -> m (Coercion a b)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Coercion a b -> m (Coercion a b)Source# | |
| (Data (f a),Data a,Typeable f) =>Data (Alt f a)Source# | Since: 4.8.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Alt f a -> c (Alt f a)Source# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (Alt f a)Source# toConstr ::Alt f a ->ConstrSource# dataTypeOf ::Alt f a ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (Alt f a))Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (Alt f a))Source# gmapT :: (forall b.Data b => b -> b) ->Alt f a ->Alt f aSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Alt f a -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Alt f a -> rSource# gmapQ :: (forall d.Data d => d -> u) ->Alt f a -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->Alt f a -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->Alt f a -> m (Alt f a)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Alt f a -> m (Alt f a)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Alt f a -> m (Alt f a)Source# | |
| (Data (f a),Data a,Typeable f) =>Data (Ap f a)Source# | Since: 4.12.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Ap f a -> c (Ap f a)Source# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (Ap f a)Source# toConstr ::Ap f a ->ConstrSource# dataTypeOf ::Ap f a ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (Ap f a))Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (Ap f a))Source# gmapT :: (forall b.Data b => b -> b) ->Ap f a ->Ap f aSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Ap f a -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Ap f a -> rSource# gmapQ :: (forall d.Data d => d -> u) ->Ap f a -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->Ap f a -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->Ap f a -> m (Ap f a)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Ap f a -> m (Ap f a)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Ap f a -> m (Ap f a)Source# | |
| Functor (K1 i c ::Type ->Type)Source# | Since: 4.9.0.0 |
| (Functor f,Functor g) =>Functor (f:+: g)Source# | Since: 4.9.0.0 |
| (Functor f,Functor g) =>Functor (f:*: g)Source# | Since: 4.9.0.0 |
| (Functor f,Functor g) =>Functor (Sum f g)Source# | Since: 4.9.0.0 |
| (Functor f,Functor g) =>Functor (Product f g)Source# | Since: 4.9.0.0 |
| (Applicative f,Num a) =>Num (Ap f a)Source# | Since: 4.12.0.0 |
| (MonadFix f,MonadFix g) =>MonadFix (f:*: g)Source# | Since: 4.9.0.0 |
| (MonadFix f,MonadFix g) =>MonadFix (Product f g)Source# | Since: 4.9.0.0 |
| IsString a =>IsString (Const a b)Source# | Since: 4.9.0.0 |
| Monoid c =>Applicative (K1 i c ::Type ->Type)Source# | Since: 4.12.0.0 |
| (Applicative f,Applicative g) =>Applicative (f:*: g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
| (Applicative f,Applicative g) =>Applicative (Product f g)Source# | Since: 4.9.0.0 |
| Foldable (K1 i c ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>K1 i c m -> mSource# foldMap ::Monoid m => (a -> m) ->K1 i c a -> mSource# foldr :: (a -> b -> b) -> b ->K1 i c a -> bSource# foldr' :: (a -> b -> b) -> b ->K1 i c a -> bSource# foldl :: (b -> a -> b) -> b ->K1 i c a -> bSource# foldl' :: (b -> a -> b) -> b ->K1 i c a -> bSource# foldr1 :: (a -> a -> a) ->K1 i c a -> aSource# foldl1 :: (a -> a -> a) ->K1 i c a -> aSource# toList ::K1 i c a -> [a]Source# length ::K1 i c a ->IntSource# elem ::Eq a => a ->K1 i c a ->BoolSource# maximum ::Ord a =>K1 i c a -> aSource# minimum ::Ord a =>K1 i c a -> aSource# | |
| (Foldable f,Foldable g) =>Foldable (f:+: g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m => (f:+: g) m -> mSource# foldMap ::Monoid m => (a -> m) -> (f:+: g) a -> mSource# foldr :: (a -> b -> b) -> b -> (f:+: g) a -> bSource# foldr' :: (a -> b -> b) -> b -> (f:+: g) a -> bSource# foldl :: (b -> a -> b) -> b -> (f:+: g) a -> bSource# foldl' :: (b -> a -> b) -> b -> (f:+: g) a -> bSource# foldr1 :: (a -> a -> a) -> (f:+: g) a -> aSource# foldl1 :: (a -> a -> a) -> (f:+: g) a -> aSource# toList :: (f:+: g) a -> [a]Source# null :: (f:+: g) a ->BoolSource# length :: (f:+: g) a ->IntSource# elem ::Eq a => a -> (f:+: g) a ->BoolSource# maximum ::Ord a => (f:+: g) a -> aSource# minimum ::Ord a => (f:+: g) a -> aSource# | |
| (Foldable f,Foldable g) =>Foldable (f:*: g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m => (f:*: g) m -> mSource# foldMap ::Monoid m => (a -> m) -> (f:*: g) a -> mSource# foldr :: (a -> b -> b) -> b -> (f:*: g) a -> bSource# foldr' :: (a -> b -> b) -> b -> (f:*: g) a -> bSource# foldl :: (b -> a -> b) -> b -> (f:*: g) a -> bSource# foldl' :: (b -> a -> b) -> b -> (f:*: g) a -> bSource# foldr1 :: (a -> a -> a) -> (f:*: g) a -> aSource# foldl1 :: (a -> a -> a) -> (f:*: g) a -> aSource# toList :: (f:*: g) a -> [a]Source# null :: (f:*: g) a ->BoolSource# length :: (f:*: g) a ->IntSource# elem ::Eq a => a -> (f:*: g) a ->BoolSource# maximum ::Ord a => (f:*: g) a -> aSource# minimum ::Ord a => (f:*: g) a -> aSource# | |
| (Foldable f,Foldable g) =>Foldable (Sum f g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Sum Methods fold ::Monoid m =>Sum f g m -> mSource# foldMap ::Monoid m => (a -> m) ->Sum f g a -> mSource# foldr :: (a -> b -> b) -> b ->Sum f g a -> bSource# foldr' :: (a -> b -> b) -> b ->Sum f g a -> bSource# foldl :: (b -> a -> b) -> b ->Sum f g a -> bSource# foldl' :: (b -> a -> b) -> b ->Sum f g a -> bSource# foldr1 :: (a -> a -> a) ->Sum f g a -> aSource# foldl1 :: (a -> a -> a) ->Sum f g a -> aSource# toList ::Sum f g a -> [a]Source# null ::Sum f g a ->BoolSource# length ::Sum f g a ->IntSource# elem ::Eq a => a ->Sum f g a ->BoolSource# maximum ::Ord a =>Sum f g a -> aSource# minimum ::Ord a =>Sum f g a -> aSource# | |
| (Foldable f,Foldable g) =>Foldable (Product f g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Product Methods fold ::Monoid m =>Product f g m -> mSource# foldMap ::Monoid m => (a -> m) ->Product f g a -> mSource# foldr :: (a -> b -> b) -> b ->Product f g a -> bSource# foldr' :: (a -> b -> b) -> b ->Product f g a -> bSource# foldl :: (b -> a -> b) -> b ->Product f g a -> bSource# foldl' :: (b -> a -> b) -> b ->Product f g a -> bSource# foldr1 :: (a -> a -> a) ->Product f g a -> aSource# foldl1 :: (a -> a -> a) ->Product f g a -> aSource# toList ::Product f g a -> [a]Source# null ::Product f g a ->BoolSource# length ::Product f g a ->IntSource# elem ::Eq a => a ->Product f g a ->BoolSource# maximum ::Ord a =>Product f g a -> aSource# minimum ::Ord a =>Product f g a -> aSource# | |
| Traversable (K1 i c ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| (Traversable f,Traversable g) =>Traversable (f:+: g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| (Traversable f,Traversable g) =>Traversable (f:*: g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| (Traversable f,Traversable g) =>Traversable (Sum f g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Sum | |
| (Traversable f,Traversable g) =>Traversable (Product f g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Product Methods traverse ::Applicative f0 => (a -> f0 b) ->Product f g a -> f0 (Product f g b)Source# sequenceA ::Applicative f0 =>Product f g (f0 a) -> f0 (Product f g a)Source# mapM ::Monad m => (a -> m b) ->Product f g a -> m (Product f g b)Source# sequence ::Monad m =>Product f g (m a) -> m (Product f g a)Source# | |
| Alternative f =>Semigroup (Alt f a)Source# | Since: 4.9.0.0 |
| (Applicative f,Semigroup a) =>Semigroup (Ap f a)Source# | Since: 4.12.0.0 |
| Alternative f =>Monoid (Alt f a)Source# | Since: 4.8.0.0 |
| (Applicative f,Monoid a) =>Monoid (Ap f a)Source# | Since: 4.12.0.0 |
| (MonadPlus f,MonadPlus g) =>MonadPlus (f:*: g)Source# | Since: 4.9.0.0 |
| (MonadPlus f,MonadPlus g) =>MonadPlus (Product f g)Source# | Since: 4.9.0.0 |
| (Alternative f,Alternative g) =>Alternative (f:*: g)Source# | Since: 4.9.0.0 |
| (Alternative f,Alternative g) =>Alternative (Product f g)Source# | Since: 4.9.0.0 |
| (MonadZip f,MonadZip g) =>MonadZip (f:*: g)Source# | Since: 4.9.0.0 |
| (MonadZip f,MonadZip g) =>MonadZip (Product f g)Source# | Since: 4.9.0.0 |
| (Show1 f,Show1 g) =>Show1 (Sum f g)Source# | Since: 4.9.0.0 |
| (Show1 f,Show1 g) =>Show1 (Product f g)Source# | Since: 4.9.0.0 |
| (Read1 f,Read1 g) =>Read1 (Sum f g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Sum | |
| (Read1 f,Read1 g) =>Read1 (Product f g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Product Methods liftReadsPrec :: (Int ->ReadS a) ->ReadS [a] ->Int ->ReadS (Product f g a)Source# liftReadList :: (Int ->ReadS a) ->ReadS [a] ->ReadS [Product f g a]Source# liftReadPrec ::ReadPrec a ->ReadPrec [a] ->ReadPrec (Product f g a)Source# liftReadListPrec ::ReadPrec a ->ReadPrec [a] ->ReadPrec [Product f g a]Source# | |
| (Ord1 f,Ord1 g) =>Ord1 (Sum f g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Sum | |
| (Ord1 f,Ord1 g) =>Ord1 (Product f g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Product | |
| (Eq1 f,Eq1 g) =>Eq1 (Sum f g)Source# | Since: 4.9.0.0 |
| (Eq1 f,Eq1 g) =>Eq1 (Product f g)Source# | Since: 4.9.0.0 |
| Contravariant (K1 i c ::Type ->Type)Source# | |
| (Contravariant f,Contravariant g) =>Contravariant (f:+: g)Source# | |
| (Contravariant f,Contravariant g) =>Contravariant (f:*: g)Source# | |
| (Contravariant f,Contravariant g) =>Contravariant (Sum f g)Source# | |
| (Contravariant f,Contravariant g) =>Contravariant (Product f g)Source# | |
| (Eq1 f,Eq1 g,Eq a) =>Eq (Sum f g a)Source# | Since: 4.9.0.0 |
| (Eq1 f,Eq1 g,Eq a) =>Eq (Product f g a)Source# | Since: 4.9.0.0 |
| Monad f =>Monad (M1 i c f)Source# | Since: 4.9.0.0 |
| (Typeable i,Data p,Data c) =>Data (K1 i c p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) ->K1 i c p -> c0 (K1 i c p)Source# gunfold :: (forall b r.Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) ->Constr -> c0 (K1 i c p)Source# toConstr ::K1 i c p ->ConstrSource# dataTypeOf ::K1 i c p ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c0 (t d)) ->Maybe (c0 (K1 i c p))Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c0 (t d e)) ->Maybe (c0 (K1 i c p))Source# gmapT :: (forall b.Data b => b -> b) ->K1 i c p ->K1 i c pSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->K1 i c p -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->K1 i c p -> rSource# gmapQ :: (forall d.Data d => d -> u) ->K1 i c p -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->K1 i c p -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->K1 i c p -> m (K1 i c p)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->K1 i c p -> m (K1 i c p)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->K1 i c p -> m (K1 i c p)Source# | |
| (Typeable f,Typeable g,Data p,Data (f p),Data (g p)) =>Data ((f:+: g) p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f:+: g) p -> c ((f:+: g) p)Source# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c ((f:+: g) p)Source# toConstr :: (f:+: g) p ->ConstrSource# dataTypeOf :: (f:+: g) p ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c ((f:+: g) p))Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c ((f:+: g) p))Source# gmapT :: (forall b.Data b => b -> b) -> (f:+: g) p -> (f:+: g) pSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') -> (f:+: g) p -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') -> (f:+: g) p -> rSource# gmapQ :: (forall d.Data d => d -> u) -> (f:+: g) p -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) -> (f:+: g) p -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) -> (f:+: g) p -> m ((f:+: g) p)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) -> (f:+: g) p -> m ((f:+: g) p)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) -> (f:+: g) p -> m ((f:+: g) p)Source# | |
| (Typeable f,Typeable g,Data p,Data (f p),Data (g p)) =>Data ((f:*: g) p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f:*: g) p -> c ((f:*: g) p)Source# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c ((f:*: g) p)Source# toConstr :: (f:*: g) p ->ConstrSource# dataTypeOf :: (f:*: g) p ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c ((f:*: g) p))Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c ((f:*: g) p))Source# gmapT :: (forall b.Data b => b -> b) -> (f:*: g) p -> (f:*: g) pSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') -> (f:*: g) p -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') -> (f:*: g) p -> rSource# gmapQ :: (forall d.Data d => d -> u) -> (f:*: g) p -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) -> (f:*: g) p -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) -> (f:*: g) p -> m ((f:*: g) p)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) -> (f:*: g) p -> m ((f:*: g) p)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) -> (f:*: g) p -> m ((f:*: g) p)Source# | |
| Functor f =>Functor (M1 i c f)Source# | Since: 4.9.0.0 |
| (Functor f,Functor g) =>Functor (f:.: g)Source# | Since: 4.9.0.0 |
| (Functor f,Functor g) =>Functor (Compose f g)Source# | Since: 4.9.0.0 |
| (Ord1 f,Ord1 g,Ord a) =>Ord (Sum f g a)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Sum | |
| (Ord1 f,Ord1 g,Ord a) =>Ord (Product f g a)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Product | |
| (Read1 f,Read1 g,Read a) =>Read (Sum f g a)Source# | Since: 4.9.0.0 |
| (Read1 f,Read1 g,Read a) =>Read (Product f g a)Source# | Since: 4.9.0.0 |
| (Show1 f,Show1 g,Show a) =>Show (Sum f g a)Source# | Since: 4.9.0.0 |
| (Show1 f,Show1 g,Show a) =>Show (Product f g a)Source# | Since: 4.9.0.0 |
| MonadFix f =>MonadFix (M1 i c f)Source# | Since: 4.9.0.0 |
| Applicative f =>Applicative (M1 i c f)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
| (Applicative f,Applicative g) =>Applicative (f:.: g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
| (Applicative f,Applicative g) =>Applicative (Compose f g)Source# | Since: 4.9.0.0 |
| Foldable f =>Foldable (M1 i c f)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>M1 i c f m -> mSource# foldMap ::Monoid m => (a -> m) ->M1 i c f a -> mSource# foldr :: (a -> b -> b) -> b ->M1 i c f a -> bSource# foldr' :: (a -> b -> b) -> b ->M1 i c f a -> bSource# foldl :: (b -> a -> b) -> b ->M1 i c f a -> bSource# foldl' :: (b -> a -> b) -> b ->M1 i c f a -> bSource# foldr1 :: (a -> a -> a) ->M1 i c f a -> aSource# foldl1 :: (a -> a -> a) ->M1 i c f a -> aSource# toList ::M1 i c f a -> [a]Source# null ::M1 i c f a ->BoolSource# length ::M1 i c f a ->IntSource# elem ::Eq a => a ->M1 i c f a ->BoolSource# maximum ::Ord a =>M1 i c f a -> aSource# minimum ::Ord a =>M1 i c f a -> aSource# | |
| (Foldable f,Foldable g) =>Foldable (f:.: g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m => (f:.: g) m -> mSource# foldMap ::Monoid m => (a -> m) -> (f:.: g) a -> mSource# foldr :: (a -> b -> b) -> b -> (f:.: g) a -> bSource# foldr' :: (a -> b -> b) -> b -> (f:.: g) a -> bSource# foldl :: (b -> a -> b) -> b -> (f:.: g) a -> bSource# foldl' :: (b -> a -> b) -> b -> (f:.: g) a -> bSource# foldr1 :: (a -> a -> a) -> (f:.: g) a -> aSource# foldl1 :: (a -> a -> a) -> (f:.: g) a -> aSource# toList :: (f:.: g) a -> [a]Source# null :: (f:.: g) a ->BoolSource# length :: (f:.: g) a ->IntSource# elem ::Eq a => a -> (f:.: g) a ->BoolSource# maximum ::Ord a => (f:.: g) a -> aSource# minimum ::Ord a => (f:.: g) a -> aSource# | |
| (Foldable f,Foldable g) =>Foldable (Compose f g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Compose Methods fold ::Monoid m =>Compose f g m -> mSource# foldMap ::Monoid m => (a -> m) ->Compose f g a -> mSource# foldr :: (a -> b -> b) -> b ->Compose f g a -> bSource# foldr' :: (a -> b -> b) -> b ->Compose f g a -> bSource# foldl :: (b -> a -> b) -> b ->Compose f g a -> bSource# foldl' :: (b -> a -> b) -> b ->Compose f g a -> bSource# foldr1 :: (a -> a -> a) ->Compose f g a -> aSource# foldl1 :: (a -> a -> a) ->Compose f g a -> aSource# toList ::Compose f g a -> [a]Source# null ::Compose f g a ->BoolSource# length ::Compose f g a ->IntSource# elem ::Eq a => a ->Compose f g a ->BoolSource# maximum ::Ord a =>Compose f g a -> aSource# minimum ::Ord a =>Compose f g a -> aSource# | |
| Traversable f =>Traversable (M1 i c f)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| (Traversable f,Traversable g) =>Traversable (f:.: g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Traversable | |
| (Traversable f,Traversable g) =>Traversable (Compose f g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Compose Methods traverse ::Applicative f0 => (a -> f0 b) ->Compose f g a -> f0 (Compose f g b)Source# sequenceA ::Applicative f0 =>Compose f g (f0 a) -> f0 (Compose f g a)Source# mapM ::Monad m => (a -> m b) ->Compose f g a -> m (Compose f g b)Source# sequence ::Monad m =>Compose f g (m a) -> m (Compose f g a)Source# | |
| MonadPlus f =>MonadPlus (M1 i c f)Source# | Since: 4.9.0.0 |
| Alternative f =>Alternative (M1 i c f)Source# | Since: 4.9.0.0 |
| (Alternative f,Applicative g) =>Alternative (f:.: g)Source# | Since: 4.9.0.0 |
| (Alternative f,Applicative g) =>Alternative (Compose f g)Source# | Since: 4.9.0.0 |
| MonadZip f =>MonadZip (M1 i c f)Source# | Since: 4.9.0.0 |
| (Show1 f,Show1 g) =>Show1 (Compose f g)Source# | Since: 4.9.0.0 |
| (Read1 f,Read1 g) =>Read1 (Compose f g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Compose Methods liftReadsPrec :: (Int ->ReadS a) ->ReadS [a] ->Int ->ReadS (Compose f g a)Source# liftReadList :: (Int ->ReadS a) ->ReadS [a] ->ReadS [Compose f g a]Source# liftReadPrec ::ReadPrec a ->ReadPrec [a] ->ReadPrec (Compose f g a)Source# liftReadListPrec ::ReadPrec a ->ReadPrec [a] ->ReadPrec [Compose f g a]Source# | |
| (Ord1 f,Ord1 g) =>Ord1 (Compose f g)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Compose | |
| (Eq1 f,Eq1 g) =>Eq1 (Compose f g)Source# | Since: 4.9.0.0 |
| Contravariant f =>Contravariant (M1 i c f)Source# | |
| (Functor f,Contravariant g) =>Contravariant (f:.: g)Source# | |
| (Functor f,Contravariant g) =>Contravariant (Compose f g)Source# | |
| (Eq1 f,Eq1 g,Eq a) =>Eq (Compose f g a)Source# | Since: 4.9.0.0 |
| (Data p,Data (f p),Typeable c,Typeable i,Typeable f) =>Data (M1 i c f p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) ->M1 i c f p -> c0 (M1 i c f p)Source# gunfold :: (forall b r.Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) ->Constr -> c0 (M1 i c f p)Source# toConstr ::M1 i c f p ->ConstrSource# dataTypeOf ::M1 i c f p ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c0 (t d)) ->Maybe (c0 (M1 i c f p))Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c0 (t d e)) ->Maybe (c0 (M1 i c f p))Source# gmapT :: (forall b.Data b => b -> b) ->M1 i c f p ->M1 i c f pSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->M1 i c f p -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->M1 i c f p -> rSource# gmapQ :: (forall d.Data d => d -> u) ->M1 i c f p -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->M1 i c f p -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->M1 i c f p -> m (M1 i c f p)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->M1 i c f p -> m (M1 i c f p)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->M1 i c f p -> m (M1 i c f p)Source# | |
| (Typeable f,Typeable g,Data p,Data (f (g p))) =>Data ((f:.: g) p)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f:.: g) p -> c ((f:.: g) p)Source# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c ((f:.: g) p)Source# toConstr :: (f:.: g) p ->ConstrSource# dataTypeOf :: (f:.: g) p ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c ((f:.: g) p))Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c ((f:.: g) p))Source# gmapT :: (forall b.Data b => b -> b) -> (f:.: g) p -> (f:.: g) pSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') -> (f:.: g) p -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') -> (f:.: g) p -> rSource# gmapQ :: (forall d.Data d => d -> u) -> (f:.: g) p -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) -> (f:.: g) p -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) -> (f:.: g) p -> m ((f:.: g) p)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) -> (f:.: g) p -> m ((f:.: g) p)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) -> (f:.: g) p -> m ((f:.: g) p)Source# | |
| (Ord1 f,Ord1 g,Ord a) =>Ord (Compose f g a)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Compose | |
| (Read1 f,Read1 g,Read a) =>Read (Compose f g a)Source# | Since: 4.9.0.0 |
| (Show1 f,Show1 g,Show a) =>Show (Compose f g a)Source# | Since: 4.9.0.0 |
| typeRep1 (f:.: g :: k ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
| typeRep1 (Compose f g :: k ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Functor.Compose | |
| typeRep1 []Source# | Since: 4.6.0.0 |
Instance detailsDefined inGHC.Generics typeRep1 [] =D1 (MetaData "[]" "GHC.Types" "ghc-prim"False) (C1 (MetaCons "[]"PrefixIFalse) (U1 ::Type ->Type):+:C1 (MetaCons ":" (InfixILeftAssociative 9)False) (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy)Par1:*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec1 []))) | |
| typeRep1MaybeSource# | Since: 4.6.0.0 |
| typeRep1Par1Source# | Since: 4.9.0.0 |
Instance detailsDefined inGHC.Generics | |
| typeRep1NonEmptySource# | Since: 4.6.0.0 |
Instance detailsDefined inGHC.Generics typeRep1NonEmpty =D1 (MetaData "NonEmpty" "GHC.Base" "base"False) (C1 (MetaCons ":|" (InfixILeftAssociative 9)False) (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy)Par1:*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec1 []))) | |
| typeRep1DownSource# | Since: 4.12.0.0 |
Instance detailsDefined inGHC.Generics | |
| typeRep1ProductSource# | Since: 4.7.0.0 |
Instance detailsDefined inData.Semigroup.Internal | |
| typeRep1SumSource# | Since: 4.7.0.0 |
Instance detailsDefined inData.Semigroup.Internal | |
| typeRep1DualSource# | Since: 4.7.0.0 |
Instance detailsDefined inData.Semigroup.Internal | |
| typeRep1LastSource# | Since: 4.7.0.0 |
Instance detailsDefined inData.Monoid | |
| typeRep1FirstSource# | Since: 4.7.0.0 |
Instance detailsDefined inData.Monoid | |
| typeRep1IdentitySource# | Since: 4.8.0.0 |
Instance detailsDefined inData.Functor.Identity | |
| typeRep1ZipListSource# | Since: 4.7.0.0 |
Instance detailsDefined inControl.Applicative | |
| typeRep1OptionSource# | Since: 4.9.0.0 |
Instance detailsDefined inData.Semigroup | |
| typeRep1WrappedMonoidSource# | Since: 4.9.0.0 |
Instance detailsDefined inData.Semigroup typeRep1WrappedMonoid =D1 (MetaData "WrappedMonoid" "Data.Semigroup" "base"True) (C1 (MetaCons "WrapMonoid"PrefixITrue) (S1 (MetaSel (Just "unwrapMonoid")NoSourceUnpackednessNoSourceStrictnessDecidedLazy)Par1)) | |
| typeRep1LastSource# | Since: 4.9.0.0 |
Instance detailsDefined inData.Semigroup | |
| typeRep1FirstSource# | Since: 4.9.0.0 |
Instance detailsDefined inData.Semigroup | |
| typeRep1MaxSource# | Since: 4.9.0.0 |
Instance detailsDefined inData.Semigroup | |
| typeRep1MinSource# | Since: 4.9.0.0 |
Instance detailsDefined inData.Semigroup | |
| typeRep1ComplexSource# | Since: 4.9.0.0 |
Instance detailsDefined inData.Complex typeRep1Complex =D1 (MetaData "Complex" "Data.Complex" "base"False) (C1 (MetaCons ":+" (InfixINotAssociative 6)False) (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessSourceStrictDecidedStrict)Par1:*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessSourceStrictDecidedStrict)Par1)) | |
| typeRep1 (Either a ::Type ->Type)Source# | Since: 4.6.0.0 |
Instance detailsDefined inGHC.Generics typeRep1 (Either a ::Type ->Type) =D1 (MetaData "Either" "Data.Either" "base"False) (C1 (MetaCons "Left"PrefixIFalse) (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 a)):+:C1 (MetaCons "Right"PrefixIFalse) (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy)Par1)) | |
| typeRep1 ((,) a ::Type ->Type)Source# | Since: 4.6.0.0 |
Instance detailsDefined inGHC.Generics typeRep1 ((,) a ::Type ->Type) =D1 (MetaData "(,)" "GHC.Tuple" "ghc-prim"False) (C1 (MetaCons "(,)"PrefixIFalse) (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 a):*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy)Par1)) | |
| typeRep1 (WrappedMonad m ::Type ->Type)Source# | Since: 4.7.0.0 |
Instance detailsDefined inControl.Applicative typeRep1 (WrappedMonad m ::Type ->Type) =D1 (MetaData "WrappedMonad" "Control.Applicative" "base"True) (C1 (MetaCons "WrapMonad"PrefixITrue) (S1 (MetaSel (Just "unwrapMonad")NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec1 m))) | |
| typeRep1 (Arg a ::Type ->Type)Source# | Since: 4.9.0.0 |
Instance detailsDefined inData.Semigroup typeRep1 (Arg a ::Type ->Type) =D1 (MetaData "Arg" "Data.Semigroup" "base"False) (C1 (MetaCons "Arg"PrefixIFalse) (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 a):*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy)Par1)) | |
| typeRep1 ((,,) a b ::Type ->Type)Source# | Since: 4.6.0.0 |
Instance detailsDefined inGHC.Generics typeRep1 ((,,) a b ::Type ->Type) =D1 (MetaData "(,,)" "GHC.Tuple" "ghc-prim"False) (C1 (MetaCons "(,,)"PrefixIFalse) (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 a):*: (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 b):*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy)Par1))) | |
| typeRep1 (WrappedArrow a b ::Type ->Type)Source# | Since: 4.7.0.0 |
Instance detailsDefined inControl.Applicative typeRep1 (WrappedArrow a b ::Type ->Type) =D1 (MetaData "WrappedArrow" "Control.Applicative" "base"True) (C1 (MetaCons "WrapArrow"PrefixITrue) (S1 (MetaSel (Just "unwrapArrow")NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec1 (a b)))) | |
| typeRep1 ((,,,) a b c ::Type ->Type)Source# | Since: 4.6.0.0 |
Instance detailsDefined inGHC.Generics typeRep1 ((,,,) a b c ::Type ->Type) =D1 (MetaData "(,,,)" "GHC.Tuple" "ghc-prim"False) (C1 (MetaCons "(,,,)"PrefixIFalse) ((S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 a):*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 b)):*: (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 c):*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy)Par1))) | |
| typeRep1 ((,,,,) a b c d ::Type ->Type)Source# | Since: 4.6.0.0 |
Instance detailsDefined inGHC.Generics typeRep1 ((,,,,) a b c d ::Type ->Type) =D1 (MetaData "(,,,,)" "GHC.Tuple" "ghc-prim"False) (C1 (MetaCons "(,,,,)"PrefixIFalse) ((S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 a):*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 b)):*: (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 c):*: (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 d):*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy)Par1)))) | |
| typeRep1 ((,,,,,) a b c d e ::Type ->Type)Source# | Since: 4.6.0.0 |
Instance detailsDefined inGHC.Generics typeRep1 ((,,,,,) a b c d e ::Type ->Type) =D1 (MetaData "(,,,,,)" "GHC.Tuple" "ghc-prim"False) (C1 (MetaCons "(,,,,,)"PrefixIFalse) ((S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 a):*: (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 b):*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 c))):*: (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 d):*: (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 e):*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy)Par1)))) | |
| typeRep1 ((,,,,,,) a b c d e f ::Type ->Type)Source# | Since: 4.6.0.0 |
Instance detailsDefined inGHC.Generics typeRep1 ((,,,,,,) a b c d e f ::Type ->Type) =D1 (MetaData "(,,,,,,)" "GHC.Tuple" "ghc-prim"False) (C1 (MetaCons "(,,,,,,)"PrefixIFalse) ((S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 a):*: (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 b):*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 c))):*: ((S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 d):*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 e)):*: (S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy) (Rec0 f):*:S1 (MetaSel (Nothing ::MaybeSymbol)NoSourceUnpackednessNoSourceStrictnessDecidedLazy)Par1)))) | |
dataRuntimeRep#
GHC maintains a property that the kind of all inhabited types (as distinct from type constructors or type-level data) tells us the runtime representation of values of that type. This datatype encodes the choice of runtime value. Note thatTYPE is parameterised byRuntimeRep; this is precisely what we mean by the fact that a type's kind encodes the runtime representation.
For boxed values (that is, values that are represented by a pointer), a further distinction is made, between lifted types (that contain ⊥), and unlifted ones (that don't).
Constructors
| VecRepVecCountVecElem | a SIMD vector type |
| TupleRep [RuntimeRep] | An unboxed tuple of the given reps |
| SumRep [RuntimeRep] | An unboxed sum of the given reps |
| LiftedRep | lifted; represented by a pointer |
| UnliftedRep | unlifted; represented by a pointer |
| IntRep | signed, word-sized value |
| WordRep | unsigned, word-sized value |
| Int64Rep | signed, 64-bit value (on 32-bit only) |
| Word64Rep | unsigned, 64-bit value (on 32-bit only) |
| AddrRep | A pointer, butnot to a Haskell value |
| FloatRep | a 32-bit floating point number |
| DoubleRep | a 64-bit floating point number |
Length of a SIMD vector type
| BoundedVecCountSource# | Since: 4.10.0.0 |
| EnumVecCountSource# | Since: 4.10.0.0 |
Instance detailsDefined inGHC.Enum Methods succ ::VecCount ->VecCountSource# pred ::VecCount ->VecCountSource# toEnum ::Int ->VecCountSource# fromEnum ::VecCount ->IntSource# enumFrom ::VecCount -> [VecCount]Source# enumFromThen ::VecCount ->VecCount -> [VecCount]Source# enumFromTo ::VecCount ->VecCount -> [VecCount]Source# enumFromThenTo ::VecCount ->VecCount ->VecCount -> [VecCount]Source# | |
| ShowVecCountSource# | Since: 4.11.0.0 |
Element of a SIMD vector type
Constructors
| Int8ElemRep | |
| Int16ElemRep | |
| Int32ElemRep | |
| Int64ElemRep | |
| Word8ElemRep | |
| Word16ElemRep | |
| Word32ElemRep | |
| Word64ElemRep | |
| FloatElemRep | |
| DoubleElemRep |
| BoundedVecElemSource# | Since: 4.10.0.0 |
| EnumVecElemSource# | Since: 4.10.0.0 |
Instance detailsDefined inGHC.Enum Methods succ ::VecElem ->VecElemSource# pred ::VecElem ->VecElemSource# fromEnum ::VecElem ->IntSource# enumFrom ::VecElem -> [VecElem]Source# enumFromThen ::VecElem ->VecElem -> [VecElem]Source# enumFromTo ::VecElem ->VecElem -> [VecElem]Source# enumFromThenTo ::VecElem ->VecElem ->VecElem -> [VecElem]Source# | |
| ShowVecElemSource# | Since: 4.11.0.0 |
TheDown type allows you to reverse sort order conveniently. A value of typeDown aa (represented asDown aa has anOrdthen sortWith byDown x
Since: 4.6.0.0
Constructors
| Down a |
| MonadDownSource# | Since: 4.11.0.0 |
| FunctorDownSource# | Since: 4.11.0.0 |
| MonadFixDownSource# | Since: 4.12.0.0 |
| ApplicativeDownSource# | Since: 4.11.0.0 |
| FoldableDownSource# | Since: 4.12.0.0 |
Instance detailsDefined inData.Foldable Methods fold ::Monoid m =>Down m -> mSource# foldMap ::Monoid m => (a -> m) ->Down a -> mSource# foldr :: (a -> b -> b) -> b ->Down a -> bSource# foldr' :: (a -> b -> b) -> b ->Down a -> bSource# foldl :: (b -> a -> b) -> b ->Down a -> bSource# foldl' :: (b -> a -> b) -> b ->Down a -> bSource# foldr1 :: (a -> a -> a) ->Down a -> aSource# foldl1 :: (a -> a -> a) ->Down a -> aSource# elem ::Eq a => a ->Down a ->BoolSource# maximum ::Ord a =>Down a -> aSource# minimum ::Ord a =>Down a -> aSource# | |
| TraversableDownSource# | Since: 4.12.0.0 |
| MonadZipDownSource# | Since: 4.12.0.0 |
| Show1DownSource# | Since: 4.12.0.0 |
| Read1DownSource# | Since: 4.12.0.0 |
Instance detailsDefined inData.Functor.Classes | |
| Ord1DownSource# | Since: 4.12.0.0 |
Instance detailsDefined inData.Functor.Classes | |
| Eq1DownSource# | Since: 4.12.0.0 |
| Eq a =>Eq (Down a)Source# | Since: 4.6.0.0 |
| Data a =>Data (Down a)Source# | Since: 4.12.0.0 |
Instance detailsDefined inData.Data Methods gfoldl :: (forall d b.Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) ->Down a -> c (Down a)Source# gunfold :: (forall b r.Data b => c (b -> r) -> c r) -> (forall r. r -> c r) ->Constr -> c (Down a)Source# toConstr ::Down a ->ConstrSource# dataTypeOf ::Down a ->DataTypeSource# dataCast1 ::Typeable t => (forall d.Data d => c (t d)) ->Maybe (c (Down a))Source# dataCast2 ::Typeable t => (forall d e. (Data d,Data e) => c (t d e)) ->Maybe (c (Down a))Source# gmapT :: (forall b.Data b => b -> b) ->Down a ->Down aSource# gmapQl :: (r -> r' -> r) -> r -> (forall d.Data d => d -> r') ->Down a -> rSource# gmapQr :: (r' -> r -> r) -> r -> (forall d.Data d => d -> r') ->Down a -> rSource# gmapQ :: (forall d.Data d => d -> u) ->Down a -> [u]Source# gmapQi ::Int -> (forall d.Data d => d -> u) ->Down a -> uSource# gmapM ::Monad m => (forall d.Data d => d -> m d) ->Down a -> m (Down a)Source# gmapMp ::MonadPlus m => (forall d.Data d => d -> m d) ->Down a -> m (Down a)Source# gmapMo ::MonadPlus m => (forall d.Data d => d -> m d) ->Down a -> m (Down a)Source# | |
| Num a =>Num (Down a)Source# | Since: 4.11.0.0 |
| Ord a =>Ord (Down a)Source# | Since: 4.6.0.0 |
| Read a =>Read (Down a)Source# | Since: 4.7.0.0 |
| Show a =>Show (Down a)Source# | Since: 4.7.0.0 |
| Generic (Down a)Source# | |
| Semigroup a =>Semigroup (Down a)Source# | Since: 4.11.0.0 |
| Monoid a =>Monoid (Down a)Source# | Since: 4.11.0.0 |
| Generic1DownSource# | |
| typeRep (Down a)Source# | Since: 4.12.0.0 |
Instance detailsDefined inGHC.Generics | |
| typeRep1DownSource# | Since: 4.12.0.0 |
Instance detailsDefined inGHC.Generics | |
groupWith ::Ord b => (a -> b) -> [a] -> [[a]]Source#
ThegroupWith function uses the user supplied function which projects an element out of every list element in order to first sort the input list and then to form groups by equality on these projected elements
sortWith ::Ord b => (a -> b) -> [a] -> [a]Source#
ThesortWith function sorts a list of elements using the user supplied function to project something out of each element
the ensures that all the elements of the list are identical and then returns that unique element
traceEvent ::String ->IO ()Source#
Deprecated: UsetraceEvent ortraceEventIO
dataSpecConstrAnnotationSource#
Constructors
| NoSpecConstr | |
| ForceSpecConstr |
currentCallStack ::IO [String]Source#
Returns a[String] representing the current call stack. This can be useful for debugging.
The implementation uses the call-stack simulation maintained by the profiler, so it only works if the program was compiled with-prof and contains suitable SCC annotations (e.g. by using-fprof-auto). Otherwise, the list returned is likely to be empty or uninformative.
Since: 4.5.0.0
dataConstraint#
The kind of constraints, likeShow a
type familyAny :: k0where ...#
The type constructorAny is type to which you can unsafely coerce any lifted type, and back. More concretely, for a lifted typet and valuex :: t, --unsafeCoerce (unsafeCoerce x :: Any) :: t is equivalent tox.
TheIsList class and its methods are intended to be used in conjunction with the OverloadedLists extension.
Since: 4.7.0.0
Methods
fromList :: [Item l] -> lSource#
ThefromList function constructs the structurel from the given list ofItem l
fromListN ::Int -> [Item l] -> lSource#
ThefromListN function takes the input list's length as a hint. Its behaviour should be equivalent tofromList. The hint can be used to construct the structurel more efficiently compared tofromList. If the given hint does not equal to the input list's length the behaviour offromListN is not specified.
toList :: l -> [Item l]Source#
ThetoList function extracts a list ofItem l from the structurel. It should satisfy fromList . toList = id.
Produced byHaddock version 2.20.0