diff --git a/GHC/CString.hs b/GHC/CString.hs --- a/GHC/CString.hs +++ b/GHC/CString.hs @@ -24,7 +24,7 @@ import GHC.Prim ----------------------------------------------------------------------------- --- Unpacking C strings} +-- Unpacking C strings ----------------------------------------------------------------------------- -- This code is needed for virtually all programs, since it's used for @@ -34,11 +34,33 @@ -- stuff uses Strings in the representation, so to give representations for -- ghc-prim types we need unpackCString# +{- +Note [Inlining unpackCString#] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +There's really no point in ever inlining things like unpackCString# as the loop +doesn't specialise in an interesting way and we can't deforest the list +constructors (we'd want to use unpackFoldrCString# for this). Moreover, it's +pretty small, so there's a danger that it'll be inlined at every literal, which +is a waste. + +Moreover, inlining early may interfere with a variety of rules that are supposed +to match unpackCString#, + + * BuiltInRules in PrelRules.hs; e.g. + eqString (unpackCString# (Lit s1)) (unpackCString# (Lit s2) + = s1 == s2 + + * unpacking rules; e.g. in GHC.Base, + unpackCString# a + = build (unpackFoldrCString# a) + + * stream fusion rules; e.g. in the `text` library, + unstream (S.map safe (S.streamList (GHC.unpackCString# a))) + = unpackCString# a +-} + unpackCString# :: Addr# -> [Char] {-# NOINLINE unpackCString# #-} - -- There's really no point in inlining this, ever, as the loop doesn't - -- specialise in an interesting But it's pretty small, so there's a danger - -- that it'll be inlined at every literal, which is a waste unpackCString# addr = unpack 0# where @@ -64,7 +86,7 @@ -- Usually the unpack-list rule turns unpackFoldrCString# into unpackCString# --- It also has a BuiltInRule in PrelRules.lhs: +-- It also has a BuiltInRule in PrelRules.hs: -- unpackFoldrCString# "foo" c (unpackFoldrCString# "baz" c n) -- = unpackFoldrCString# "foobaz" c n @@ -85,7 +107,10 @@ where !ch = indexCharOffAddr# addr nh +-- There's really no point in inlining this for the same reasons as +-- unpackCString. See Note [Inlining unpackCString#] above for details. unpackCStringUtf8# :: Addr# -> [Char] +{-# NOINLINE unpackCStringUtf8# #-} unpackCStringUtf8# addr = unpack 0# where @@ -110,7 +135,10 @@ where !ch = indexCharOffAddr# addr nh +-- There's really no point in inlining this for the same reasons as +-- unpackCString. See Note [Inlining unpackCString#] above for details. unpackNBytes# :: Addr# -> Int# -> [Char] +{-# NOINLINE unpackNBytes# #-} unpackNBytes# _addr 0# = [] unpackNBytes# addr len# = unpack [] (len# -# 1#) where diff --git a/GHC/Classes.hs b/GHC/Classes.hs --- a/GHC/Classes.hs +++ b/GHC/Classes.hs @@ -1,7 +1,19 @@ -{-# LANGUAGE Trustworthy #-} -{-# LANGUAGE NoImplicitPrelude, MagicHash, StandaloneDeriving, BangPatterns #-} -{-# OPTIONS_GHC -fno-warn-unused-imports #-} --- XXX -fno-warn-unused-imports needed for the GHC.Tuple import below. Sigh. +{-# LANGUAGE CPP, Trustworthy #-} +{-# LANGUAGE NoImplicitPrelude, MagicHash, StandaloneDeriving, BangPatterns, + KindSignatures, DataKinds, ConstraintKinds, + MultiParamTypeClasses, FunctionalDependencies #-} +{-# LANGUAGE AllowAmbiguousTypes #-} + -- ip :: IP x a => a is strictly speaking ambiguous, but IP is magic +{-# LANGUAGE UndecidableSuperClasses #-} + -- Because of the type-variable superclasses for tuples + +{-# OPTIONS_GHC -Wno-unused-imports #-} +-- -Wno-unused-imports needed for the GHC.Tuple import below. Sigh. + +{-# OPTIONS_GHC -Wno-unused-top-binds #-} +-- -Wno-unused-top-binds is there (I hope) to stop Haddock complaining +-- about the constraint tuples being defined but not used + {-# OPTIONS_HADDOCK hide #-} ----------------------------------------------------------------------------- -- | @@ -17,14 +29,38 @@ -- ----------------------------------------------------------------------------- -module GHC.Classes where +module GHC.Classes( + -- * Implicit paramaters + IP(..), + -- * Equality and ordering + Eq(..), + Ord(..), + -- ** Monomorphic equality operators + -- | See GHC.Classes#matching_overloaded_methods_in_rules + eqInt, neInt, + eqWord, neWord, + eqChar, neChar, + eqFloat, eqDouble, + -- ** Monomorphic comparison operators + gtInt, geInt, leInt, ltInt, compareInt, compareInt#, + gtWord, geWord, leWord, ltWord, compareWord, compareWord#, + + -- * Functions over Bool + (&&), (||), not, + + -- * Integer arithmetic + divInt#, modInt# + ) where + -- GHC.Magic is used in some derived instances import GHC.Magic () +import GHC.IntWord64 import GHC.Prim import GHC.Tuple import GHC.Types +#include "MachDeps.h" infix 4 ==, /=, <, <=, >=, > infixr 3 && @@ -32,6 +68,51 @@ default () -- Double isn't available yet +-- | The syntax @?x :: a@ is desugared into @IP "x" a@ +-- IP is declared very early, so that libraries can take +-- advantage of the implicit-call-stack feature +class IP (x :: Symbol) a | x -> a where + ip :: a + +{- $matching_overloaded_methods_in_rules + +Matching on class methods (e.g. @(==)@) in rewrite rules tends to be a bit +fragile. For instance, consider this motivating example from the @bytestring@ +library, + +> break :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString) +> breakByte :: Word8 -> ByteString -> (ByteString, ByteString) +> {-# RULES "break -> breakByte" forall a. break (== x) = breakByte x #-} + +Here we have two functions, with @breakByte@ providing an optimized +implementation of @break@ where the predicate is merely testing for equality +with a known @Word8@. As written, however, this rule will be quite fragile as +the @(==)@ class operation rule may rewrite the predicate before our @break@ +rule has a chance to fire. + +For this reason, most of the primitive types in @base@ have 'Eq' and 'Ord' +instances defined in terms of helper functions with inlinings delayed to phase +1. For instance, @Word8@\'s @Eq@ instance looks like, + +> instance Eq Word8 where +> (==) = eqWord8 +> (/=) = neWord8 +> +> eqWord8, neWord8 :: Word8 -> Word8 -> Bool +> eqWord8 (W8# x) (W8# y) = ... +> neWord8 (W8# x) (W8# y) = ... +> {-# INLINE [1] eqWord8 #-} +> {-# INLINE [1] neWord8 #-} + +This allows us to save our @break@ rule above by rewriting it to instead match +against @eqWord8@, + +> {-# RULES "break -> breakByte" forall a. break (`eqWord8` x) = breakByte x #-} + +Currently this is only done for '(==)', '(/=)', '(<)', '(<=)', '(>)', and '(>=)' +for the types in "GHC.Word" and "GHC.Int". +-} + -- | The 'Eq' class defines equality ('==') and inequality ('/='). -- All the basic datatypes exported by the "Prelude" are instances of 'Eq', -- and 'Eq' may be derived for any datatype whose constituents are also @@ -92,28 +173,82 @@ deriving instance Eq Bool deriving instance Eq Ordering -deriving instance Eq Word +instance Eq Word where + (==) = eqWord + (/=) = neWord + +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] eqWord #-} +{-# INLINE [1] neWord #-} +eqWord, neWord :: Word -> Word -> Bool +(W# x) `eqWord` (W# y) = isTrue# (x `eqWord#` y) +(W# x) `neWord` (W# y) = isTrue# (x `neWord#` y) + +-- See GHC.Classes#matching_overloaded_methods_in_rules instance Eq Char where - (C# c1) == (C# c2) = isTrue# (c1 `eqChar#` c2) - (C# c1) /= (C# c2) = isTrue# (c1 `neChar#` c2) + (==) = eqChar + (/=) = neChar +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] eqChar #-} +{-# INLINE [1] neChar #-} +eqChar, neChar :: Char -> Char -> Bool +(C# x) `eqChar` (C# y) = isTrue# (x `eqChar#` y) +(C# x) `neChar` (C# y) = isTrue# (x `neChar#` y) + instance Eq Float where - (F# x) == (F# y) = isTrue# (x `eqFloat#` y) + (==) = eqFloat +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] eqFloat #-} +eqFloat :: Float -> Float -> Bool +(F# x) `eqFloat` (F# y) = isTrue# (x `eqFloat#` y) + instance Eq Double where - (D# x) == (D# y) = isTrue# (x ==## y) + (==) = eqDouble +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] eqDouble #-} +eqDouble :: Double -> Double -> Bool +(D# x) `eqDouble` (D# y) = isTrue# (x ==## y) + instance Eq Int where (==) = eqInt (/=) = neInt -{-# INLINE eqInt #-} -{-# INLINE neInt #-} +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] eqInt #-} +{-# INLINE [1] neInt #-} eqInt, neInt :: Int -> Int -> Bool (I# x) `eqInt` (I# y) = isTrue# (x ==# y) (I# x) `neInt` (I# y) = isTrue# (x /=# y) +#if WORD_SIZE_IN_BITS < 64 +instance Eq TyCon where + (==) (TyCon hi1 lo1 _ _) (TyCon hi2 lo2 _ _) + = isTrue# (hi1 `eqWord64#` hi2) && isTrue# (lo1 `eqWord64#` lo2) +instance Ord TyCon where + compare (TyCon hi1 lo1 _ _) (TyCon hi2 lo2 _ _) + | isTrue# (hi1 `gtWord64#` hi2) = GT + | isTrue# (hi1 `ltWord64#` hi2) = LT + | isTrue# (lo1 `gtWord64#` lo2) = GT + | isTrue# (lo1 `ltWord64#` lo2) = LT + | True = EQ +#else +instance Eq TyCon where + (==) (TyCon hi1 lo1 _ _) (TyCon hi2 lo2 _ _) + = isTrue# (hi1 `eqWord#` hi2) && isTrue# (lo1 `eqWord#` lo2) +instance Ord TyCon where + compare (TyCon hi1 lo1 _ _) (TyCon hi2 lo2 _ _) + | isTrue# (hi1 `gtWord#` hi2) = GT + | isTrue# (hi1 `ltWord#` hi2) = LT + | isTrue# (lo1 `gtWord#` lo2) = GT + | isTrue# (lo1 `ltWord#` lo2) = LT + | True = EQ +#endif + + -- | The 'Ord' class is used for totally ordered datatypes. -- -- Instances of 'Ord' can be derived for any user-defined @@ -195,7 +330,6 @@ deriving instance Ord Bool deriving instance Ord Ordering -deriving instance Ord Word -- We don't use deriving for Ord Char, because for Ord the derived -- instance defines only compare, which takes two primops. Then @@ -235,10 +369,11 @@ (>=) = geInt (>) = gtInt -{-# INLINE gtInt #-} -{-# INLINE geInt #-} -{-# INLINE ltInt #-} -{-# INLINE leInt #-} +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] gtInt #-} +{-# INLINE [1] geInt #-} +{-# INLINE [1] ltInt #-} +{-# INLINE [1] leInt #-} gtInt, geInt, ltInt, leInt :: Int -> Int -> Bool (I# x) `gtInt` (I# y) = isTrue# (x ># y) (I# x) `geInt` (I# y) = isTrue# (x >=# y) @@ -254,6 +389,33 @@ | isTrue# (x# ==# y#) = EQ | True = GT +instance Ord Word where + compare = compareWord + (<) = ltWord + (<=) = leWord + (>=) = geWord + (>) = gtWord + +-- See GHC.Classes#matching_overloaded_methods_in_rules +{-# INLINE [1] gtWord #-} +{-# INLINE [1] geWord #-} +{-# INLINE [1] ltWord #-} +{-# INLINE [1] leWord #-} +gtWord, geWord, ltWord, leWord :: Word -> Word -> Bool +(W# x) `gtWord` (W# y) = isTrue# (x `gtWord#` y) +(W# x) `geWord` (W# y) = isTrue# (x `geWord#` y) +(W# x) `ltWord` (W# y) = isTrue# (x `ltWord#` y) +(W# x) `leWord` (W# y) = isTrue# (x `leWord#` y) + +compareWord :: Word -> Word -> Ordering +(W# x#) `compareWord` (W# y#) = compareWord# x# y# + +compareWord# :: Word# -> Word# -> Ordering +compareWord# x# y# + | isTrue# (x# `ltWord#` y#) = LT + | isTrue# (x# `eqWord#` y#) = EQ + | True = GT + -- OK, so they're technically not part of a class...: -- Boolean functions @@ -297,3 +459,327 @@ else r# where !r# = x# `remInt#` y# + + +{- ************************************************************* +* * +* Constraint tuples * +* * +************************************************************* -} + +class () +class (c1, c2) => (c1, c2) +class (c1, c2, c3) => (c1, c2, c3) +class (c1, c2, c3, c4) => (c1, c2, c3, c4) +class (c1, c2, c3, c4, c5) => (c1, c2, c3, c4, c5) +class (c1, c2, c3, c4, c5, c6) => (c1, c2, c3, c4, c5, c6) +class (c1, c2, c3, c4, c5, c6, c7) => (c1, c2, c3, c4, c5, c6, c7) +class (c1, c2, c3, c4, c5, c6, c7, c8) => (c1, c2, c3, c4, c5, c6, c7, c8) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17,c18) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60, c61) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60, c61) +class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60, c61, c62) + => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, + c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, + c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, + c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58, + c59, c60, c61, c62) diff --git a/GHC/IntWord64.hs b/GHC/IntWord64.hs --- a/GHC/IntWord64.hs +++ b/GHC/IntWord64.hs @@ -23,7 +23,10 @@ #endif ) where +import GHC.Types () -- Make implicit dependency known to build system + #if WORD_SIZE_IN_BITS < 64 + import GHC.Prim foreign import ccall unsafe "hs_eqWord64" eqWord64# :: Word64# -> Word64# -> Int# diff --git a/GHC/Magic.hs b/GHC/Magic.hs --- a/GHC/Magic.hs +++ b/GHC/Magic.hs @@ -1,5 +1,9 @@ +{-# LANGUAGE CPP #-} {-# LANGUAGE Trustworthy #-} {-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE UnboxedTuples #-} + ----------------------------------------------------------------------------- -- | -- Module : GHC.Magic @@ -17,8 +21,11 @@ -- ----------------------------------------------------------------------------- -module GHC.Magic ( inline, lazy, oneShot ) where +module GHC.Magic ( inline, lazy, oneShot, runRW# ) where +import GHC.Prim +import GHC.CString () + -- | The call @inline f@ arranges that 'f' is inlined, regardless of -- its size. More precisely, the call @inline f@ rewrites to the -- right-hand side of @f@'s definition. This allows the programmer to @@ -69,7 +76,26 @@ -- 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. +-- +-- If 'oneShot' 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 of `oneShot` is safe. +-- +-- 'oneShot' is open kinded, i.e. the type variables can refer to unlifted +-- types as well. oneShot :: (a -> b) -> (a -> b) oneShot f = f -- Implementation note: This is wired in in MkId.lhs, so the code here is -- mostly there to have a place for the documentation. + +-- | Apply a function to a 'RealWorld' token. +runRW# :: (State# RealWorld -> (# State# RealWorld, o #)) + -> (# State# RealWorld, o #) +-- See Note [runRW magic] in MkId +#if !defined(__HADDOCK_VERSION__) +runRW# m = m realWorld# +#else +runRW# = runRW# -- The realWorld# is too much for haddock +#endif +{-# NOINLINE runRW# #-} +-- This is inlined manually in CorePrep diff --git a/GHC/Prim.hs b/GHC/Prim.hs --- a/GHC/Prim.hs +++ b/GHC/Prim.hs @@ -22,6598 +22,6629 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE UnboxedTuples #-} -module GHC.Prim ( - --- * The word size story. --- |Haskell98 specifies that signed integers (type @Int@) --- must contain at least 30 bits. GHC always implements @Int@ using the primitive type @Int\#@, whose size equals --- the @MachDeps.h@ constant @WORD\_SIZE\_IN\_BITS@. --- This is normally set based on the @config.h@ parameter --- @SIZEOF\_HSWORD@, i.e., 32 bits on 32-bit machines, 64 --- bits on 64-bit machines. However, it can also be explicitly --- set to a smaller number, e.g., 31 bits, to allow the --- possibility of using tag bits. Currently GHC itself has only --- 32-bit and 64-bit variants, but 30 or 31-bit code can be --- exported as an external core file for use in other back ends. --- --- GHC also implements a primitive unsigned integer type @Word\#@ which always has the same number of bits as @Int\#@. --- --- In addition, GHC supports families of explicit-sized integers --- and words at 8, 16, 32, and 64 bits, with the usual --- arithmetic operations, comparisons, and a range of --- conversions. The 8-bit and 16-bit sizes are always --- represented as @Int\#@ and @Word\#@, and the --- operations implemented in terms of the the primops on these --- types, with suitable range restrictions on the results (using --- the @narrow$n$Int\#@ and @narrow$n$Word\#@ families --- of primops. The 32-bit sizes are represented using @Int\#@ and @Word\#@ when @WORD\_SIZE\_IN\_BITS@ --- $\geq$ 32; otherwise, these are represented using distinct --- primitive types @Int32\#@ and @Word32\#@. These (when --- needed) have a complete set of corresponding operations; --- however, nearly all of these are implemented as external C --- functions rather than as primops. Exactly the same story --- applies to the 64-bit sizes. All of these details are hidden --- under the @PrelInt@ and @PrelWord@ modules, which use --- @\#if@-defs to invoke the appropriate types and --- operators. --- --- Word size also matters for the families of primops for --- indexing\/reading\/writing fixed-size quantities at offsets --- from an array base, address, or foreign pointer. Here, a --- slightly different approach is taken. The names of these --- primops are fixed, but their /types/ vary according to --- the value of @WORD\_SIZE\_IN\_BITS@. For example, if word --- size is at least 32 bits then an operator like --- @indexInt32Array\#@ has type @ByteArray\# -> Int\# -> Int\#@; otherwise it has type @ByteArray\# -> Int\# -> Int32\#@. This approach confines the necessary @\#if@-defs to this file; no conditional compilation is needed --- in the files that expose these primops. --- --- Finally, there are strongly deprecated primops for coercing --- between @Addr\#@, the primitive type of machine --- addresses, and @Int\#@. These are pretty bogus anyway, --- but will work on existing 32-bit and 64-bit GHC targets; they --- are completely bogus when tag bits are used in @Int\#@, --- so are not available in this case. - - - --- * Char# --- |Operations on 31-bit characters. - - - Char#, - gtChar#, - geChar#, - eqChar#, - neChar#, - ltChar#, - leChar#, - ord#, - --- * Int# --- |Operations on native-size integers (30+ bits). - - - Int#, - (+#), - (-#), - (*#), - mulIntMayOflo#, - quotInt#, - remInt#, - quotRemInt#, - andI#, - orI#, - xorI#, - notI#, - negateInt#, - addIntC#, - subIntC#, - (>#), - (>=#), - (==#), - (/=#), - (<#), - (<=#), - chr#, - int2Word#, - int2Float#, - int2Double#, - word2Float#, - word2Double#, - uncheckedIShiftL#, - uncheckedIShiftRA#, - uncheckedIShiftRL#, - --- * Word# --- |Operations on native-sized unsigned words (30+ bits). - - - Word#, - plusWord#, - plusWord2#, - minusWord#, - timesWord#, - timesWord2#, - quotWord#, - remWord#, - quotRemWord#, - quotRemWord2#, - and#, - or#, - xor#, - not#, - uncheckedShiftL#, - uncheckedShiftRL#, - word2Int#, - gtWord#, - geWord#, - eqWord#, - neWord#, - ltWord#, - leWord#, - popCnt8#, - popCnt16#, - popCnt32#, - popCnt64#, - popCnt#, - clz8#, - clz16#, - clz32#, - clz64#, - clz#, - ctz8#, - ctz16#, - ctz32#, - ctz64#, - ctz#, - byteSwap16#, - byteSwap32#, - byteSwap64#, - byteSwap#, - --- * Narrowings --- |Explicit narrowing of native-sized ints or words. - - - narrow8Int#, - narrow16Int#, - narrow32Int#, - narrow8Word#, - narrow16Word#, - narrow32Word#, - --- * Double# --- |Operations on double-precision (64 bit) floating-point numbers. - - - Double#, - (>##), - (>=##), - (==##), - (/=##), - (<##), - (<=##), - (+##), - (-##), - (*##), - (/##), - negateDouble#, - double2Int#, - double2Float#, - expDouble#, - logDouble#, - sqrtDouble#, - sinDouble#, - cosDouble#, - tanDouble#, - asinDouble#, - acosDouble#, - atanDouble#, - sinhDouble#, - coshDouble#, - tanhDouble#, - (**##), - decodeDouble_2Int#, - decodeDouble_Int64#, - --- * Float# --- |Operations on single-precision (32-bit) floating-point numbers. - - - Float#, - gtFloat#, - geFloat#, - eqFloat#, - neFloat#, - ltFloat#, - leFloat#, - plusFloat#, - minusFloat#, - timesFloat#, - divideFloat#, - negateFloat#, - float2Int#, - expFloat#, - logFloat#, - sqrtFloat#, - sinFloat#, - cosFloat#, - tanFloat#, - asinFloat#, - acosFloat#, - atanFloat#, - sinhFloat#, - coshFloat#, - tanhFloat#, - powerFloat#, - float2Double#, - decodeFloat_Int#, - --- * Arrays --- |Operations on @Array\#@. - - - Array#, - MutableArray#, - newArray#, - sameMutableArray#, - readArray#, - writeArray#, - sizeofArray#, - sizeofMutableArray#, - indexArray#, - unsafeFreezeArray#, - unsafeThawArray#, - copyArray#, - copyMutableArray#, - cloneArray#, - cloneMutableArray#, - freezeArray#, - thawArray#, - casArray#, - --- * Small Arrays --- |Operations on @SmallArray\#@. A @SmallArray\#@ works --- just like an @Array\#@, but with different space use and --- performance characteristics (that are often useful with small --- arrays). The @SmallArray\#@ and @SmallMutableArray#@ --- lack a \`card table\'. The purpose of a card table is to avoid --- having to scan every element of the array on each GC by --- keeping track of which elements have changed since the last GC --- and only scanning those that have changed. So the consequence --- of there being no card table is that the representation is --- somewhat smaller and the writes are somewhat faster (because --- the card table does not need to be updated). The disadvantage --- of course is that for a @SmallMutableArray#@ the whole --- array has to be scanned on each GC. Thus it is best suited for --- use cases where the mutable array is not long lived, e.g. --- where a mutable array is initialised quickly and then frozen --- to become an immutable @SmallArray\#@. --- - - - SmallArray#, - SmallMutableArray#, - newSmallArray#, - sameSmallMutableArray#, - readSmallArray#, - writeSmallArray#, - sizeofSmallArray#, - sizeofSmallMutableArray#, - indexSmallArray#, - unsafeFreezeSmallArray#, - unsafeThawSmallArray#, - copySmallArray#, - copySmallMutableArray#, - cloneSmallArray#, - cloneSmallMutableArray#, - freezeSmallArray#, - thawSmallArray#, - casSmallArray#, - --- * Byte Arrays --- |Operations on @ByteArray\#@. A @ByteArray\#@ is a just a region of --- raw memory in the garbage-collected heap, which is not --- scanned for pointers. It carries its own size (in bytes). --- There are --- three sets of operations for accessing byte array contents: --- index for reading from immutable byte arrays, and read\/write --- for mutable byte arrays. Each set contains operations for a --- range of useful primitive data types. Each operation takes --- an offset measured in terms of the size of the primitive type --- being read or written. - - - ByteArray#, - MutableByteArray#, - newByteArray#, - newPinnedByteArray#, - newAlignedPinnedByteArray#, - byteArrayContents#, - sameMutableByteArray#, - shrinkMutableByteArray#, - resizeMutableByteArray#, - unsafeFreezeByteArray#, - sizeofByteArray#, - sizeofMutableByteArray#, - indexCharArray#, - indexWideCharArray#, - indexIntArray#, - indexWordArray#, - indexAddrArray#, - indexFloatArray#, - indexDoubleArray#, - indexStablePtrArray#, - indexInt8Array#, - indexInt16Array#, - indexInt32Array#, - indexInt64Array#, - indexWord8Array#, - indexWord16Array#, - indexWord32Array#, - indexWord64Array#, - readCharArray#, - readWideCharArray#, - readIntArray#, - readWordArray#, - readAddrArray#, - readFloatArray#, - readDoubleArray#, - readStablePtrArray#, - readInt8Array#, - readInt16Array#, - readInt32Array#, - readInt64Array#, - readWord8Array#, - readWord16Array#, - readWord32Array#, - readWord64Array#, - writeCharArray#, - writeWideCharArray#, - writeIntArray#, - writeWordArray#, - writeAddrArray#, - writeFloatArray#, - writeDoubleArray#, - writeStablePtrArray#, - writeInt8Array#, - writeInt16Array#, - writeInt32Array#, - writeInt64Array#, - writeWord8Array#, - writeWord16Array#, - writeWord32Array#, - writeWord64Array#, - copyByteArray#, - copyMutableByteArray#, - copyByteArrayToAddr#, - copyMutableByteArrayToAddr#, - copyAddrToByteArray#, - setByteArray#, - atomicReadIntArray#, - atomicWriteIntArray#, - casIntArray#, - fetchAddIntArray#, - fetchSubIntArray#, - fetchAndIntArray#, - fetchNandIntArray#, - fetchOrIntArray#, - fetchXorIntArray#, - --- * Arrays of arrays --- |Operations on @ArrayArray\#@. An @ArrayArray\#@ contains references to {\em unpointed} --- arrays, such as @ByteArray\#s@. Hence, it is not parameterised by the element types, --- just like a @ByteArray\#@, but it needs to be scanned during GC, just like an @Array#@. --- We represent an @ArrayArray\#@ exactly as a @Array\#@, but provide element-type-specific --- indexing, reading, and writing. - - - ArrayArray#, - MutableArrayArray#, - newArrayArray#, - sameMutableArrayArray#, - unsafeFreezeArrayArray#, - sizeofArrayArray#, - sizeofMutableArrayArray#, - indexByteArrayArray#, - indexArrayArrayArray#, - readByteArrayArray#, - readMutableByteArrayArray#, - readArrayArrayArray#, - readMutableArrayArrayArray#, - writeByteArrayArray#, - writeMutableByteArrayArray#, - writeArrayArrayArray#, - writeMutableArrayArrayArray#, - copyArrayArray#, - copyMutableArrayArray#, - --- * Addr# --- | - - - Addr#, - nullAddr#, - plusAddr#, - minusAddr#, - remAddr#, - addr2Int#, - int2Addr#, - gtAddr#, - geAddr#, - eqAddr#, - neAddr#, - ltAddr#, - leAddr#, - indexCharOffAddr#, - indexWideCharOffAddr#, - indexIntOffAddr#, - indexWordOffAddr#, - indexAddrOffAddr#, - indexFloatOffAddr#, - indexDoubleOffAddr#, - indexStablePtrOffAddr#, - indexInt8OffAddr#, - indexInt16OffAddr#, - indexInt32OffAddr#, - indexInt64OffAddr#, - indexWord8OffAddr#, - indexWord16OffAddr#, - indexWord32OffAddr#, - indexWord64OffAddr#, - readCharOffAddr#, - readWideCharOffAddr#, - readIntOffAddr#, - readWordOffAddr#, - readAddrOffAddr#, - readFloatOffAddr#, - readDoubleOffAddr#, - readStablePtrOffAddr#, - readInt8OffAddr#, - readInt16OffAddr#, - readInt32OffAddr#, - readInt64OffAddr#, - readWord8OffAddr#, - readWord16OffAddr#, - readWord32OffAddr#, - readWord64OffAddr#, - writeCharOffAddr#, - writeWideCharOffAddr#, - writeIntOffAddr#, - writeWordOffAddr#, - writeAddrOffAddr#, - writeFloatOffAddr#, - writeDoubleOffAddr#, - writeStablePtrOffAddr#, - writeInt8OffAddr#, - writeInt16OffAddr#, - writeInt32OffAddr#, - writeInt64OffAddr#, - writeWord8OffAddr#, - writeWord16OffAddr#, - writeWord32OffAddr#, - writeWord64OffAddr#, - --- * Mutable variables --- |Operations on MutVar\#s. - - - MutVar#, - newMutVar#, - readMutVar#, - writeMutVar#, - sameMutVar#, - atomicModifyMutVar#, - casMutVar#, - --- * Exceptions --- | - - - catch#, - raise#, - raiseIO#, - maskAsyncExceptions#, - maskUninterruptible#, - unmaskAsyncExceptions#, - getMaskingState#, - --- * STM-accessible Mutable Variables --- | - - - TVar#, - atomically#, - retry#, - catchRetry#, - catchSTM#, - check#, - newTVar#, - readTVar#, - readTVarIO#, - writeTVar#, - sameTVar#, - --- * Synchronized Mutable Variables --- |Operations on @MVar\#@s. - - - MVar#, - newMVar#, - takeMVar#, - tryTakeMVar#, - putMVar#, - tryPutMVar#, - readMVar#, - tryReadMVar#, - sameMVar#, - isEmptyMVar#, - --- * Delay\/wait operations --- | - - - delay#, - waitRead#, - waitWrite#, - --- * Concurrency primitives --- | - - - State#, - RealWorld, - ThreadId#, - fork#, - forkOn#, - killThread#, - yield#, - myThreadId#, - labelThread#, - isCurrentThreadBound#, - noDuplicate#, - threadStatus#, - --- * Weak pointers --- | - - - Weak#, - mkWeak#, - mkWeakNoFinalizer#, - addCFinalizerToWeak#, - deRefWeak#, - finalizeWeak#, - touch#, - --- * Stable pointers and names --- | - - - StablePtr#, - StableName#, - makeStablePtr#, - deRefStablePtr#, - eqStablePtr#, - makeStableName#, - eqStableName#, - stableNameToInt#, - --- * Unsafe pointer equality --- | - - - reallyUnsafePtrEquality#, - --- * Parallelism --- | - - - par#, - spark#, - seq#, - getSpark#, - numSparks#, - parGlobal#, - parLocal#, - parAt#, - parAtAbs#, - parAtRel#, - parAtForNow#, - --- * Tag to enum stuff --- |Convert back and forth between values of enumerated types --- and small integers. - - - dataToTag#, - tagToEnum#, - --- * Bytecode operations --- |Support for the bytecode interpreter and linker. - - - BCO#, - addrToAny#, - mkApUpd0#, - newBCO#, - unpackClosure#, - getApStackVal#, - --- * Misc --- |These aren\'t nearly as wired in as Etc... - - - getCCSOf#, - getCurrentCCS#, - --- * Etc --- |Miscellaneous built-ins - - - Proxy#, - proxy#, - seq, - Any, - AnyK, - unsafeCoerce#, - traceEvent#, - traceMarker#, - --- * Safe coercions --- | - - - coerce, - --- * SIMD Vectors --- |Operations on SIMD vectors. - - - Int8X16#, - Int16X8#, - Int32X4#, - Int64X2#, - Int8X32#, - Int16X16#, - Int32X8#, - Int64X4#, - Int8X64#, - Int16X32#, - Int32X16#, - Int64X8#, - Word8X16#, - Word16X8#, - Word32X4#, - Word64X2#, - Word8X32#, - Word16X16#, - Word32X8#, - Word64X4#, - Word8X64#, - Word16X32#, - Word32X16#, - Word64X8#, - FloatX4#, - DoubleX2#, - FloatX8#, - DoubleX4#, - FloatX16#, - DoubleX8#, - broadcastInt8X16#, - broadcastInt16X8#, - broadcastInt32X4#, - broadcastInt64X2#, - broadcastInt8X32#, - broadcastInt16X16#, - broadcastInt32X8#, - broadcastInt64X4#, - broadcastInt8X64#, - broadcastInt16X32#, - broadcastInt32X16#, - broadcastInt64X8#, - broadcastWord8X16#, - broadcastWord16X8#, - broadcastWord32X4#, - broadcastWord64X2#, - broadcastWord8X32#, - broadcastWord16X16#, - broadcastWord32X8#, - broadcastWord64X4#, - broadcastWord8X64#, - broadcastWord16X32#, - broadcastWord32X16#, - broadcastWord64X8#, - broadcastFloatX4#, - broadcastDoubleX2#, - broadcastFloatX8#, - broadcastDoubleX4#, - broadcastFloatX16#, - broadcastDoubleX8#, - packInt8X16#, - packInt16X8#, - packInt32X4#, - packInt64X2#, - packInt8X32#, - packInt16X16#, - packInt32X8#, - packInt64X4#, - packInt8X64#, - packInt16X32#, - packInt32X16#, - packInt64X8#, - packWord8X16#, - packWord16X8#, - packWord32X4#, - packWord64X2#, - packWord8X32#, - packWord16X16#, - packWord32X8#, - packWord64X4#, - packWord8X64#, - packWord16X32#, - packWord32X16#, - packWord64X8#, - packFloatX4#, - packDoubleX2#, - packFloatX8#, - packDoubleX4#, - packFloatX16#, - packDoubleX8#, - unpackInt8X16#, - unpackInt16X8#, - unpackInt32X4#, - unpackInt64X2#, - unpackInt8X32#, - unpackInt16X16#, - unpackInt32X8#, - unpackInt64X4#, - unpackInt8X64#, - unpackInt16X32#, - unpackInt32X16#, - unpackInt64X8#, - unpackWord8X16#, - unpackWord16X8#, - unpackWord32X4#, - unpackWord64X2#, - unpackWord8X32#, - unpackWord16X16#, - unpackWord32X8#, - unpackWord64X4#, - unpackWord8X64#, - unpackWord16X32#, - unpackWord32X16#, - unpackWord64X8#, - unpackFloatX4#, - unpackDoubleX2#, - unpackFloatX8#, - unpackDoubleX4#, - unpackFloatX16#, - unpackDoubleX8#, - insertInt8X16#, - insertInt16X8#, - insertInt32X4#, - insertInt64X2#, - insertInt8X32#, - insertInt16X16#, - insertInt32X8#, - insertInt64X4#, - insertInt8X64#, - insertInt16X32#, - insertInt32X16#, - insertInt64X8#, - insertWord8X16#, - insertWord16X8#, - insertWord32X4#, - insertWord64X2#, - insertWord8X32#, - insertWord16X16#, - insertWord32X8#, - insertWord64X4#, - insertWord8X64#, - insertWord16X32#, - insertWord32X16#, - insertWord64X8#, - insertFloatX4#, - insertDoubleX2#, - insertFloatX8#, - insertDoubleX4#, - insertFloatX16#, - insertDoubleX8#, - plusInt8X16#, - plusInt16X8#, - plusInt32X4#, - plusInt64X2#, - plusInt8X32#, - plusInt16X16#, - plusInt32X8#, - plusInt64X4#, - plusInt8X64#, - plusInt16X32#, - plusInt32X16#, - plusInt64X8#, - plusWord8X16#, - plusWord16X8#, - plusWord32X4#, - plusWord64X2#, - plusWord8X32#, - plusWord16X16#, - plusWord32X8#, - plusWord64X4#, - plusWord8X64#, - plusWord16X32#, - plusWord32X16#, - plusWord64X8#, - plusFloatX4#, - plusDoubleX2#, - plusFloatX8#, - plusDoubleX4#, - plusFloatX16#, - plusDoubleX8#, - minusInt8X16#, - minusInt16X8#, - minusInt32X4#, - minusInt64X2#, - minusInt8X32#, - minusInt16X16#, - minusInt32X8#, - minusInt64X4#, - minusInt8X64#, - minusInt16X32#, - minusInt32X16#, - minusInt64X8#, - minusWord8X16#, - minusWord16X8#, - minusWord32X4#, - minusWord64X2#, - minusWord8X32#, - minusWord16X16#, - minusWord32X8#, - minusWord64X4#, - minusWord8X64#, - minusWord16X32#, - minusWord32X16#, - minusWord64X8#, - minusFloatX4#, - minusDoubleX2#, - minusFloatX8#, - minusDoubleX4#, - minusFloatX16#, - minusDoubleX8#, - timesInt8X16#, - timesInt16X8#, - timesInt32X4#, - timesInt64X2#, - timesInt8X32#, - timesInt16X16#, - timesInt32X8#, - timesInt64X4#, - timesInt8X64#, - timesInt16X32#, - timesInt32X16#, - timesInt64X8#, - timesWord8X16#, - timesWord16X8#, - timesWord32X4#, - timesWord64X2#, - timesWord8X32#, - timesWord16X16#, - timesWord32X8#, - timesWord64X4#, - timesWord8X64#, - timesWord16X32#, - timesWord32X16#, - timesWord64X8#, - timesFloatX4#, - timesDoubleX2#, - timesFloatX8#, - timesDoubleX4#, - timesFloatX16#, - timesDoubleX8#, - divideFloatX4#, - divideDoubleX2#, - divideFloatX8#, - divideDoubleX4#, - divideFloatX16#, - divideDoubleX8#, - quotInt8X16#, - quotInt16X8#, - quotInt32X4#, - quotInt64X2#, - quotInt8X32#, - quotInt16X16#, - quotInt32X8#, - quotInt64X4#, - quotInt8X64#, - quotInt16X32#, - quotInt32X16#, - quotInt64X8#, - quotWord8X16#, - quotWord16X8#, - quotWord32X4#, - quotWord64X2#, - quotWord8X32#, - quotWord16X16#, - quotWord32X8#, - quotWord64X4#, - quotWord8X64#, - quotWord16X32#, - quotWord32X16#, - quotWord64X8#, - remInt8X16#, - remInt16X8#, - remInt32X4#, - remInt64X2#, - remInt8X32#, - remInt16X16#, - remInt32X8#, - remInt64X4#, - remInt8X64#, - remInt16X32#, - remInt32X16#, - remInt64X8#, - remWord8X16#, - remWord16X8#, - remWord32X4#, - remWord64X2#, - remWord8X32#, - remWord16X16#, - remWord32X8#, - remWord64X4#, - remWord8X64#, - remWord16X32#, - remWord32X16#, - remWord64X8#, - negateInt8X16#, - negateInt16X8#, - negateInt32X4#, - negateInt64X2#, - negateInt8X32#, - negateInt16X16#, - negateInt32X8#, - negateInt64X4#, - negateInt8X64#, - negateInt16X32#, - negateInt32X16#, - negateInt64X8#, - negateFloatX4#, - negateDoubleX2#, - negateFloatX8#, - negateDoubleX4#, - negateFloatX16#, - negateDoubleX8#, - indexInt8X16Array#, - indexInt16X8Array#, - indexInt32X4Array#, - indexInt64X2Array#, - indexInt8X32Array#, - indexInt16X16Array#, - indexInt32X8Array#, - indexInt64X4Array#, - indexInt8X64Array#, - indexInt16X32Array#, - indexInt32X16Array#, - indexInt64X8Array#, - indexWord8X16Array#, - indexWord16X8Array#, - indexWord32X4Array#, - indexWord64X2Array#, - indexWord8X32Array#, - indexWord16X16Array#, - indexWord32X8Array#, - indexWord64X4Array#, - indexWord8X64Array#, - indexWord16X32Array#, - indexWord32X16Array#, - indexWord64X8Array#, - indexFloatX4Array#, - indexDoubleX2Array#, - indexFloatX8Array#, - indexDoubleX4Array#, - indexFloatX16Array#, - indexDoubleX8Array#, - readInt8X16Array#, - readInt16X8Array#, - readInt32X4Array#, - readInt64X2Array#, - readInt8X32Array#, - readInt16X16Array#, - readInt32X8Array#, - readInt64X4Array#, - readInt8X64Array#, - readInt16X32Array#, - readInt32X16Array#, - readInt64X8Array#, - readWord8X16Array#, - readWord16X8Array#, - readWord32X4Array#, - readWord64X2Array#, - readWord8X32Array#, - readWord16X16Array#, - readWord32X8Array#, - readWord64X4Array#, - readWord8X64Array#, - readWord16X32Array#, - readWord32X16Array#, - readWord64X8Array#, - readFloatX4Array#, - readDoubleX2Array#, - readFloatX8Array#, - readDoubleX4Array#, - readFloatX16Array#, - readDoubleX8Array#, - writeInt8X16Array#, - writeInt16X8Array#, - writeInt32X4Array#, - writeInt64X2Array#, - writeInt8X32Array#, - writeInt16X16Array#, - writeInt32X8Array#, - writeInt64X4Array#, - writeInt8X64Array#, - writeInt16X32Array#, - writeInt32X16Array#, - writeInt64X8Array#, - writeWord8X16Array#, - writeWord16X8Array#, - writeWord32X4Array#, - writeWord64X2Array#, - writeWord8X32Array#, - writeWord16X16Array#, - writeWord32X8Array#, - writeWord64X4Array#, - writeWord8X64Array#, - writeWord16X32Array#, - writeWord32X16Array#, - writeWord64X8Array#, - writeFloatX4Array#, - writeDoubleX2Array#, - writeFloatX8Array#, - writeDoubleX4Array#, - writeFloatX16Array#, - writeDoubleX8Array#, - indexInt8X16OffAddr#, - indexInt16X8OffAddr#, - indexInt32X4OffAddr#, - indexInt64X2OffAddr#, - indexInt8X32OffAddr#, - indexInt16X16OffAddr#, - indexInt32X8OffAddr#, - indexInt64X4OffAddr#, - indexInt8X64OffAddr#, - indexInt16X32OffAddr#, - indexInt32X16OffAddr#, - indexInt64X8OffAddr#, - indexWord8X16OffAddr#, - indexWord16X8OffAddr#, - indexWord32X4OffAddr#, - indexWord64X2OffAddr#, - indexWord8X32OffAddr#, - indexWord16X16OffAddr#, - indexWord32X8OffAddr#, - indexWord64X4OffAddr#, - indexWord8X64OffAddr#, - indexWord16X32OffAddr#, - indexWord32X16OffAddr#, - indexWord64X8OffAddr#, - indexFloatX4OffAddr#, - indexDoubleX2OffAddr#, - indexFloatX8OffAddr#, - indexDoubleX4OffAddr#, - indexFloatX16OffAddr#, - indexDoubleX8OffAddr#, - readInt8X16OffAddr#, - readInt16X8OffAddr#, - readInt32X4OffAddr#, - readInt64X2OffAddr#, - readInt8X32OffAddr#, - readInt16X16OffAddr#, - readInt32X8OffAddr#, - readInt64X4OffAddr#, - readInt8X64OffAddr#, - readInt16X32OffAddr#, - readInt32X16OffAddr#, - readInt64X8OffAddr#, - readWord8X16OffAddr#, - readWord16X8OffAddr#, - readWord32X4OffAddr#, - readWord64X2OffAddr#, - readWord8X32OffAddr#, - readWord16X16OffAddr#, - readWord32X8OffAddr#, - readWord64X4OffAddr#, - readWord8X64OffAddr#, - readWord16X32OffAddr#, - readWord32X16OffAddr#, - readWord64X8OffAddr#, - readFloatX4OffAddr#, - readDoubleX2OffAddr#, - readFloatX8OffAddr#, - readDoubleX4OffAddr#, - readFloatX16OffAddr#, - readDoubleX8OffAddr#, - writeInt8X16OffAddr#, - writeInt16X8OffAddr#, - writeInt32X4OffAddr#, - writeInt64X2OffAddr#, - writeInt8X32OffAddr#, - writeInt16X16OffAddr#, - writeInt32X8OffAddr#, - writeInt64X4OffAddr#, - writeInt8X64OffAddr#, - writeInt16X32OffAddr#, - writeInt32X16OffAddr#, - writeInt64X8OffAddr#, - writeWord8X16OffAddr#, - writeWord16X8OffAddr#, - writeWord32X4OffAddr#, - writeWord64X2OffAddr#, - writeWord8X32OffAddr#, - writeWord16X16OffAddr#, - writeWord32X8OffAddr#, - writeWord64X4OffAddr#, - writeWord8X64OffAddr#, - writeWord16X32OffAddr#, - writeWord32X16OffAddr#, - writeWord64X8OffAddr#, - writeFloatX4OffAddr#, - writeDoubleX2OffAddr#, - writeFloatX8OffAddr#, - writeDoubleX4OffAddr#, - writeFloatX16OffAddr#, - writeDoubleX8OffAddr#, - indexInt8ArrayAsInt8X16#, - indexInt16ArrayAsInt16X8#, - indexInt32ArrayAsInt32X4#, - indexInt64ArrayAsInt64X2#, - indexInt8ArrayAsInt8X32#, - indexInt16ArrayAsInt16X16#, - indexInt32ArrayAsInt32X8#, - indexInt64ArrayAsInt64X4#, - indexInt8ArrayAsInt8X64#, - indexInt16ArrayAsInt16X32#, - indexInt32ArrayAsInt32X16#, - indexInt64ArrayAsInt64X8#, - indexWord8ArrayAsWord8X16#, - indexWord16ArrayAsWord16X8#, - indexWord32ArrayAsWord32X4#, - indexWord64ArrayAsWord64X2#, - indexWord8ArrayAsWord8X32#, - indexWord16ArrayAsWord16X16#, - indexWord32ArrayAsWord32X8#, - indexWord64ArrayAsWord64X4#, - indexWord8ArrayAsWord8X64#, - indexWord16ArrayAsWord16X32#, - indexWord32ArrayAsWord32X16#, - indexWord64ArrayAsWord64X8#, - indexFloatArrayAsFloatX4#, - indexDoubleArrayAsDoubleX2#, - indexFloatArrayAsFloatX8#, - indexDoubleArrayAsDoubleX4#, - indexFloatArrayAsFloatX16#, - indexDoubleArrayAsDoubleX8#, - readInt8ArrayAsInt8X16#, - readInt16ArrayAsInt16X8#, - readInt32ArrayAsInt32X4#, - readInt64ArrayAsInt64X2#, - readInt8ArrayAsInt8X32#, - readInt16ArrayAsInt16X16#, - readInt32ArrayAsInt32X8#, - readInt64ArrayAsInt64X4#, - readInt8ArrayAsInt8X64#, - readInt16ArrayAsInt16X32#, - readInt32ArrayAsInt32X16#, - readInt64ArrayAsInt64X8#, - readWord8ArrayAsWord8X16#, - readWord16ArrayAsWord16X8#, - readWord32ArrayAsWord32X4#, - readWord64ArrayAsWord64X2#, - readWord8ArrayAsWord8X32#, - readWord16ArrayAsWord16X16#, - readWord32ArrayAsWord32X8#, - readWord64ArrayAsWord64X4#, - readWord8ArrayAsWord8X64#, - readWord16ArrayAsWord16X32#, - readWord32ArrayAsWord32X16#, - readWord64ArrayAsWord64X8#, - readFloatArrayAsFloatX4#, - readDoubleArrayAsDoubleX2#, - readFloatArrayAsFloatX8#, - readDoubleArrayAsDoubleX4#, - readFloatArrayAsFloatX16#, - readDoubleArrayAsDoubleX8#, - writeInt8ArrayAsInt8X16#, - writeInt16ArrayAsInt16X8#, - writeInt32ArrayAsInt32X4#, - writeInt64ArrayAsInt64X2#, - writeInt8ArrayAsInt8X32#, - writeInt16ArrayAsInt16X16#, - writeInt32ArrayAsInt32X8#, - writeInt64ArrayAsInt64X4#, - writeInt8ArrayAsInt8X64#, - writeInt16ArrayAsInt16X32#, - writeInt32ArrayAsInt32X16#, - writeInt64ArrayAsInt64X8#, - writeWord8ArrayAsWord8X16#, - writeWord16ArrayAsWord16X8#, - writeWord32ArrayAsWord32X4#, - writeWord64ArrayAsWord64X2#, - writeWord8ArrayAsWord8X32#, - writeWord16ArrayAsWord16X16#, - writeWord32ArrayAsWord32X8#, - writeWord64ArrayAsWord64X4#, - writeWord8ArrayAsWord8X64#, - writeWord16ArrayAsWord16X32#, - writeWord32ArrayAsWord32X16#, - writeWord64ArrayAsWord64X8#, - writeFloatArrayAsFloatX4#, - writeDoubleArrayAsDoubleX2#, - writeFloatArrayAsFloatX8#, - writeDoubleArrayAsDoubleX4#, - writeFloatArrayAsFloatX16#, - writeDoubleArrayAsDoubleX8#, - indexInt8OffAddrAsInt8X16#, - indexInt16OffAddrAsInt16X8#, - indexInt32OffAddrAsInt32X4#, - indexInt64OffAddrAsInt64X2#, - indexInt8OffAddrAsInt8X32#, - indexInt16OffAddrAsInt16X16#, - indexInt32OffAddrAsInt32X8#, - indexInt64OffAddrAsInt64X4#, - indexInt8OffAddrAsInt8X64#, - indexInt16OffAddrAsInt16X32#, - indexInt32OffAddrAsInt32X16#, - indexInt64OffAddrAsInt64X8#, - indexWord8OffAddrAsWord8X16#, - indexWord16OffAddrAsWord16X8#, - indexWord32OffAddrAsWord32X4#, - indexWord64OffAddrAsWord64X2#, - indexWord8OffAddrAsWord8X32#, - indexWord16OffAddrAsWord16X16#, - indexWord32OffAddrAsWord32X8#, - indexWord64OffAddrAsWord64X4#, - indexWord8OffAddrAsWord8X64#, - indexWord16OffAddrAsWord16X32#, - indexWord32OffAddrAsWord32X16#, - indexWord64OffAddrAsWord64X8#, - indexFloatOffAddrAsFloatX4#, - indexDoubleOffAddrAsDoubleX2#, - indexFloatOffAddrAsFloatX8#, - indexDoubleOffAddrAsDoubleX4#, - indexFloatOffAddrAsFloatX16#, - indexDoubleOffAddrAsDoubleX8#, - readInt8OffAddrAsInt8X16#, - readInt16OffAddrAsInt16X8#, - readInt32OffAddrAsInt32X4#, - readInt64OffAddrAsInt64X2#, - readInt8OffAddrAsInt8X32#, - readInt16OffAddrAsInt16X16#, - readInt32OffAddrAsInt32X8#, - readInt64OffAddrAsInt64X4#, - readInt8OffAddrAsInt8X64#, - readInt16OffAddrAsInt16X32#, - readInt32OffAddrAsInt32X16#, - readInt64OffAddrAsInt64X8#, - readWord8OffAddrAsWord8X16#, - readWord16OffAddrAsWord16X8#, - readWord32OffAddrAsWord32X4#, - readWord64OffAddrAsWord64X2#, - readWord8OffAddrAsWord8X32#, - readWord16OffAddrAsWord16X16#, - readWord32OffAddrAsWord32X8#, - readWord64OffAddrAsWord64X4#, - readWord8OffAddrAsWord8X64#, - readWord16OffAddrAsWord16X32#, - readWord32OffAddrAsWord32X16#, - readWord64OffAddrAsWord64X8#, - readFloatOffAddrAsFloatX4#, - readDoubleOffAddrAsDoubleX2#, - readFloatOffAddrAsFloatX8#, - readDoubleOffAddrAsDoubleX4#, - readFloatOffAddrAsFloatX16#, - readDoubleOffAddrAsDoubleX8#, - writeInt8OffAddrAsInt8X16#, - writeInt16OffAddrAsInt16X8#, - writeInt32OffAddrAsInt32X4#, - writeInt64OffAddrAsInt64X2#, - writeInt8OffAddrAsInt8X32#, - writeInt16OffAddrAsInt16X16#, - writeInt32OffAddrAsInt32X8#, - writeInt64OffAddrAsInt64X4#, - writeInt8OffAddrAsInt8X64#, - writeInt16OffAddrAsInt16X32#, - writeInt32OffAddrAsInt32X16#, - writeInt64OffAddrAsInt64X8#, - writeWord8OffAddrAsWord8X16#, - writeWord16OffAddrAsWord16X8#, - writeWord32OffAddrAsWord32X4#, - writeWord64OffAddrAsWord64X2#, - writeWord8OffAddrAsWord8X32#, - writeWord16OffAddrAsWord16X16#, - writeWord32OffAddrAsWord32X8#, - writeWord64OffAddrAsWord64X4#, - writeWord8OffAddrAsWord8X64#, - writeWord16OffAddrAsWord16X32#, - writeWord32OffAddrAsWord32X16#, - writeWord64OffAddrAsWord64X8#, - writeFloatOffAddrAsFloatX4#, - writeDoubleOffAddrAsDoubleX2#, - writeFloatOffAddrAsFloatX8#, - writeDoubleOffAddrAsDoubleX4#, - writeFloatOffAddrAsFloatX16#, - writeDoubleOffAddrAsDoubleX8#, - --- * Prefetch --- |Prefetch operations: Note how every prefetch operation has a name --- with the pattern prefetch*N#, where N is either 0,1,2, or 3. --- --- This suffix number, N, is the \"locality level\" of the prefetch, following the --- convention in GCC and other compilers. --- Higher locality numbers correspond to the memory being loaded in more --- levels of the cpu cache, and being retained after initial use. The naming --- convention follows the naming convention of the prefetch intrinsic found --- in the GCC and Clang C compilers. --- --- On the LLVM backend, prefetch*N# uses the LLVM prefetch intrinsic --- with locality level N. The code generated by LLVM is target architecture --- dependent, but should agree with the GHC NCG on x86 systems. --- --- On the Sparc and PPC native backends, prefetch*N is a No-Op. --- --- On the x86 NCG, N=0 will generate prefetchNTA, --- N=1 generates prefetcht2, N=2 generates prefetcht1, and --- N=3 generates prefetcht0. --- --- For streaming workloads, the prefetch*0 operations are recommended. --- For workloads which do many reads or writes to a memory location in a short period of time, --- prefetch*3 operations are recommended. --- --- For further reading about prefetch and associated systems performance optimization, --- the instruction set and optimization manuals by Intel and other CPU vendors are --- excellent starting place. --- --- --- The \"Intel 64 and IA-32 Architectures Optimization Reference Manual\" is --- especially a helpful read, even if your software is meant for other CPU --- architectures or vendor hardware. The manual can be found at --- http:\/\/www.intel.com\/content\/www\/us\/en\/architecture-and-technology\/64-ia-32-architectures-optimization-manual.html . --- --- The @prefetch*@ family of operations has the order of operations --- determined by passing around the @State#@ token. --- --- To get a \"pure\" version of these operations, use @inlinePerformIO@ which is quite safe in this context. --- --- It is important to note that while the prefetch operations will never change the --- answer to a pure computation, They CAN change the memory locations resident --- in a CPU cache and that may change the performance and timing characteristics --- of an application. The prefetch operations are marked has_side_effects=True --- to reflect that these operations have side effects with respect to the runtime --- performance characteristics of the resulting code. Additionally, if the prefetchValue --- operations did not have this attribute, GHC does a float out transformation that --- results in a let\/app violation, at least with the current design. --- - - - prefetchByteArray3#, - prefetchMutableByteArray3#, - prefetchAddr3#, - prefetchValue3#, - prefetchByteArray2#, - prefetchMutableByteArray2#, - prefetchAddr2#, - prefetchValue2#, - prefetchByteArray1#, - prefetchMutableByteArray1#, - prefetchAddr1#, - prefetchValue1#, - prefetchByteArray0#, - prefetchMutableByteArray0#, - prefetchAddr0#, - prefetchValue0#, -) where - -{- -has_side_effects = False -out_of_line = False -can_fail = False -commutable = False -code_size = { primOpCodeSizeDefault } -strictness = { \ arity -> mkClosedStrictSig (replicate arity topDmd) topRes } -fixity = Nothing -llvm_only = False - --} -import GHC.Types (Coercible) - -data Char# - -gtChar# :: Char# -> Char# -> Int# -gtChar# = let x = x in x - -geChar# :: Char# -> Char# -> Int# -geChar# = let x = x in x - -eqChar# :: Char# -> Char# -> Int# -eqChar# = let x = x in x - -neChar# :: Char# -> Char# -> Int# -neChar# = let x = x in x - -ltChar# :: Char# -> Char# -> Int# -ltChar# = let x = x in x - -leChar# :: Char# -> Char# -> Int# -leChar# = let x = x in x - -ord# :: Char# -> Int# -ord# = let x = x in x - -data Int# - -infixl 6 +# -(+#) :: Int# -> Int# -> Int# -(+#) = let x = x in x - -infixl 6 -# -(-#) :: Int# -> Int# -> Int# -(-#) = let x = x in x - --- |Low word of signed integer multiply. - -infixl 7 *# -(*#) :: Int# -> Int# -> Int# -(*#) = let x = x in x - --- |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 recommmended 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. --- - -mulIntMayOflo# :: Int# -> Int# -> Int# -mulIntMayOflo# = let x = x in x - --- |Rounds towards zero. - -quotInt# :: Int# -> Int# -> Int# -quotInt# = let x = x in x - --- |Satisfies @(quotInt\# x y) *\# y +\# (remInt\# x y) == x@. - -remInt# :: Int# -> Int# -> Int# -remInt# = let x = x in x - --- |Rounds towards zero. - -quotRemInt# :: Int# -> Int# -> (# Int#,Int# #) -quotRemInt# = let x = x in x - -andI# :: Int# -> Int# -> Int# -andI# = let x = x in x - -orI# :: Int# -> Int# -> Int# -orI# = let x = x in x - -xorI# :: Int# -> Int# -> Int# -xorI# = let x = x in x - -notI# :: Int# -> Int# -notI# = let x = x in x - -negateInt# :: Int# -> Int# -negateInt# = let x = x in x - --- |Add signed integers reporting overflow. --- First member of result is the sum truncated to an @Int#@; --- second member is zero if the true sum fits in an @Int#@, --- nonzero if overflow occurred (the sum is either too large --- or too small to fit in an @Int#@). - -addIntC# :: Int# -> Int# -> (# Int#,Int# #) -addIntC# = let x = x in x - --- |Subtract signed integers reporting overflow. --- First member of result is the difference truncated to an @Int#@; --- second member is zero if the true difference fits in an @Int#@, --- nonzero if overflow occurred (the difference is either too large --- or too small to fit in an @Int#@). - -subIntC# :: Int# -> Int# -> (# Int#,Int# #) -subIntC# = let x = x in x - -infix 4 ># -(>#) :: Int# -> Int# -> Int# -(>#) = let x = x in x - -infix 4 >=# -(>=#) :: Int# -> Int# -> Int# -(>=#) = let x = x in x - -infix 4 ==# -(==#) :: Int# -> Int# -> Int# -(==#) = let x = x in x - -infix 4 /=# -(/=#) :: Int# -> Int# -> Int# -(/=#) = let x = x in x - -infix 4 <# -(<#) :: Int# -> Int# -> Int# -(<#) = let x = x in x - -infix 4 <=# -(<=#) :: Int# -> Int# -> Int# -(<=#) = let x = x in x - -chr# :: Int# -> Char# -chr# = let x = x in x - -int2Word# :: Int# -> Word# -int2Word# = let x = x in x - -int2Float# :: Int# -> Float# -int2Float# = let x = x in x - -int2Double# :: Int# -> Double# -int2Double# = let x = x in x - -word2Float# :: Word# -> Float# -word2Float# = let x = x in x - -word2Double# :: Word# -> Double# -word2Double# = let x = x in x - --- |Shift left. Result undefined if shift amount is not --- in the range 0 to word size - 1 inclusive. - -uncheckedIShiftL# :: Int# -> Int# -> Int# -uncheckedIShiftL# = let x = x in x - --- |Shift right arithmetic. Result undefined if shift amount is not --- in the range 0 to word size - 1 inclusive. - -uncheckedIShiftRA# :: Int# -> Int# -> Int# -uncheckedIShiftRA# = let x = x in x - --- |Shift right logical. Result undefined if shift amount is not --- in the range 0 to word size - 1 inclusive. - -uncheckedIShiftRL# :: Int# -> Int# -> Int# -uncheckedIShiftRL# = let x = x in x - -data Word# - -plusWord# :: Word# -> Word# -> Word# -plusWord# = let x = x in x - -plusWord2# :: Word# -> Word# -> (# Word#,Word# #) -plusWord2# = let x = x in x - -minusWord# :: Word# -> Word# -> Word# -minusWord# = let x = x in x - -timesWord# :: Word# -> Word# -> Word# -timesWord# = let x = x in x - -timesWord2# :: Word# -> Word# -> (# Word#,Word# #) -timesWord2# = let x = x in x - -quotWord# :: Word# -> Word# -> Word# -quotWord# = let x = x in x - -remWord# :: Word# -> Word# -> Word# -remWord# = let x = x in x - -quotRemWord# :: Word# -> Word# -> (# Word#,Word# #) -quotRemWord# = let x = x in x - -quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #) -quotRemWord2# = let x = x in x - -and# :: Word# -> Word# -> Word# -and# = let x = x in x - -or# :: Word# -> Word# -> Word# -or# = let x = x in x - -xor# :: Word# -> Word# -> Word# -xor# = let x = x in x - -not# :: Word# -> Word# -not# = let x = x in x - --- |Shift left logical. Result undefined if shift amount is not --- in the range 0 to word size - 1 inclusive. - -uncheckedShiftL# :: Word# -> Int# -> Word# -uncheckedShiftL# = let x = x in x - --- |Shift right logical. Result undefined if shift amount is not --- in the range 0 to word size - 1 inclusive. - -uncheckedShiftRL# :: Word# -> Int# -> Word# -uncheckedShiftRL# = let x = x in x - -word2Int# :: Word# -> Int# -word2Int# = let x = x in x - -gtWord# :: Word# -> Word# -> Int# -gtWord# = let x = x in x - -geWord# :: Word# -> Word# -> Int# -geWord# = let x = x in x - -eqWord# :: Word# -> Word# -> Int# -eqWord# = let x = x in x - -neWord# :: Word# -> Word# -> Int# -neWord# = let x = x in x - -ltWord# :: Word# -> Word# -> Int# -ltWord# = let x = x in x - -leWord# :: Word# -> Word# -> Int# -leWord# = let x = x in x - --- |Count the number of set bits in the lower 8 bits of a word. - -popCnt8# :: Word# -> Word# -popCnt8# = let x = x in x - --- |Count the number of set bits in the lower 16 bits of a word. - -popCnt16# :: Word# -> Word# -popCnt16# = let x = x in x - --- |Count the number of set bits in the lower 32 bits of a word. - -popCnt32# :: Word# -> Word# -popCnt32# = let x = x in x - --- |Count the number of set bits in a 64-bit word. - -popCnt64# :: Word# -> Word# -popCnt64# = let x = x in x - --- |Count the number of set bits in a word. - -popCnt# :: Word# -> Word# -popCnt# = let x = x in x - --- |Count leading zeros in the lower 8 bits of a word. - -clz8# :: Word# -> Word# -clz8# = let x = x in x - --- |Count leading zeros in the lower 16 bits of a word. - -clz16# :: Word# -> Word# -clz16# = let x = x in x - --- |Count leading zeros in the lower 32 bits of a word. - -clz32# :: Word# -> Word# -clz32# = let x = x in x - --- |Count leading zeros in a 64-bit word. - -clz64# :: Word# -> Word# -clz64# = let x = x in x - --- |Count leading zeros in a word. - -clz# :: Word# -> Word# -clz# = let x = x in x - --- |Count trailing zeros in the lower 8 bits of a word. - -ctz8# :: Word# -> Word# -ctz8# = let x = x in x - --- |Count trailing zeros in the lower 16 bits of a word. - -ctz16# :: Word# -> Word# -ctz16# = let x = x in x - --- |Count trailing zeros in the lower 32 bits of a word. - -ctz32# :: Word# -> Word# -ctz32# = let x = x in x - --- |Count trailing zeros in a 64-bit word. - -ctz64# :: Word# -> Word# -ctz64# = let x = x in x - --- |Count trailing zeros in a word. - -ctz# :: Word# -> Word# -ctz# = let x = x in x - --- |Swap bytes in the lower 16 bits of a word. The higher bytes are undefined. - -byteSwap16# :: Word# -> Word# -byteSwap16# = let x = x in x - --- |Swap bytes in the lower 32 bits of a word. The higher bytes are undefined. - -byteSwap32# :: Word# -> Word# -byteSwap32# = let x = x in x - --- |Swap bytes in a 64 bits of a word. - -byteSwap64# :: Word# -> Word# -byteSwap64# = let x = x in x - --- |Swap bytes in a word. - -byteSwap# :: Word# -> Word# -byteSwap# = let x = x in x - -narrow8Int# :: Int# -> Int# -narrow8Int# = let x = x in x - -narrow16Int# :: Int# -> Int# -narrow16Int# = let x = x in x - -narrow32Int# :: Int# -> Int# -narrow32Int# = let x = x in x - -narrow8Word# :: Word# -> Word# -narrow8Word# = let x = x in x - -narrow16Word# :: Word# -> Word# -narrow16Word# = let x = x in x - -narrow32Word# :: Word# -> Word# -narrow32Word# = let x = x in x - -data Double# - -infix 4 >## -(>##) :: Double# -> Double# -> Int# -(>##) = let x = x in x - -infix 4 >=## -(>=##) :: Double# -> Double# -> Int# -(>=##) = let x = x in x - -infix 4 ==## -(==##) :: Double# -> Double# -> Int# -(==##) = let x = x in x - -infix 4 /=## -(/=##) :: Double# -> Double# -> Int# -(/=##) = let x = x in x - -infix 4 <## -(<##) :: Double# -> Double# -> Int# -(<##) = let x = x in x - -infix 4 <=## -(<=##) :: Double# -> Double# -> Int# -(<=##) = let x = x in x - -infixl 6 +## -(+##) :: Double# -> Double# -> Double# -(+##) = let x = x in x - -infixl 6 -## -(-##) :: Double# -> Double# -> Double# -(-##) = let x = x in x - -infixl 7 *## -(*##) :: Double# -> Double# -> Double# -(*##) = let x = x in x - -infixl 7 /## -(/##) :: Double# -> Double# -> Double# -(/##) = let x = x in x - -negateDouble# :: Double# -> Double# -negateDouble# = let x = x in x - --- |Truncates a @Double#@ value to the nearest @Int#@. --- Results are undefined if the truncation if truncation yields --- a value outside the range of @Int#@. - -double2Int# :: Double# -> Int# -double2Int# = let x = x in x - -double2Float# :: Double# -> Float# -double2Float# = let x = x in x - -expDouble# :: Double# -> Double# -expDouble# = let x = x in x - -logDouble# :: Double# -> Double# -logDouble# = let x = x in x - -sqrtDouble# :: Double# -> Double# -sqrtDouble# = let x = x in x - -sinDouble# :: Double# -> Double# -sinDouble# = let x = x in x - -cosDouble# :: Double# -> Double# -cosDouble# = let x = x in x - -tanDouble# :: Double# -> Double# -tanDouble# = let x = x in x - -asinDouble# :: Double# -> Double# -asinDouble# = let x = x in x - -acosDouble# :: Double# -> Double# -acosDouble# = let x = x in x - -atanDouble# :: Double# -> Double# -atanDouble# = let x = x in x - -sinhDouble# :: Double# -> Double# -sinhDouble# = let x = x in x - -coshDouble# :: Double# -> Double# -coshDouble# = let x = x in x - -tanhDouble# :: Double# -> Double# -tanhDouble# = let x = x in x - --- |Exponentiation. - -(**##) :: Double# -> Double# -> Double# -(**##) = let x = x in x - --- |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_2Int# :: Double# -> (# Int#,Word#,Word#,Int# #) -decodeDouble_2Int# = let x = x in x - --- |Decode @Double\#@ into mantissa and base-2 exponent. - -decodeDouble_Int64# :: Double# -> (# Int#,Int# #) -decodeDouble_Int64# = let x = x in x - -data Float# - -gtFloat# :: Float# -> Float# -> Int# -gtFloat# = let x = x in x - -geFloat# :: Float# -> Float# -> Int# -geFloat# = let x = x in x - -eqFloat# :: Float# -> Float# -> Int# -eqFloat# = let x = x in x - -neFloat# :: Float# -> Float# -> Int# -neFloat# = let x = x in x - -ltFloat# :: Float# -> Float# -> Int# -ltFloat# = let x = x in x - -leFloat# :: Float# -> Float# -> Int# -leFloat# = let x = x in x - -plusFloat# :: Float# -> Float# -> Float# -plusFloat# = let x = x in x - -minusFloat# :: Float# -> Float# -> Float# -minusFloat# = let x = x in x - -timesFloat# :: Float# -> Float# -> Float# -timesFloat# = let x = x in x - -divideFloat# :: Float# -> Float# -> Float# -divideFloat# = let x = x in x - -negateFloat# :: Float# -> Float# -negateFloat# = let x = x in x - --- |Truncates a @Float#@ value to the nearest @Int#@. --- Results are undefined if the truncation if truncation yields --- a value outside the range of @Int#@. - -float2Int# :: Float# -> Int# -float2Int# = let x = x in x - -expFloat# :: Float# -> Float# -expFloat# = let x = x in x - -logFloat# :: Float# -> Float# -logFloat# = let x = x in x - -sqrtFloat# :: Float# -> Float# -sqrtFloat# = let x = x in x - -sinFloat# :: Float# -> Float# -sinFloat# = let x = x in x - -cosFloat# :: Float# -> Float# -cosFloat# = let x = x in x - -tanFloat# :: Float# -> Float# -tanFloat# = let x = x in x - -asinFloat# :: Float# -> Float# -asinFloat# = let x = x in x - -acosFloat# :: Float# -> Float# -acosFloat# = let x = x in x - -atanFloat# :: Float# -> Float# -atanFloat# = let x = x in x - -sinhFloat# :: Float# -> Float# -sinhFloat# = let x = x in x - -coshFloat# :: Float# -> Float# -coshFloat# = let x = x in x - -tanhFloat# :: Float# -> Float# -tanhFloat# = let x = x in x - -powerFloat# :: Float# -> Float# -> Float# -powerFloat# = let x = x in x - -float2Double# :: Float# -> Double# -float2Double# = let x = x in x - --- |Convert to integers. --- First @Int\#@ in result is the mantissa; second is the exponent. - -decodeFloat_Int# :: Float# -> (# Int#,Int# #) -decodeFloat_Int# = let x = x in x - -data Array# a - -data MutableArray# s 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. - -newArray# :: Int# -> a -> State# s -> (# State# s,MutableArray# s a #) -newArray# = let x = x in x - -sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int# -sameMutableArray# = let x = x in x - --- |Read from specified index of mutable array. Result is not yet evaluated. - -readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s,a #) -readArray# = let x = x in x - --- |Write to specified index of mutable array. - -writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s -writeArray# = let x = x in x - --- |Return the number of elements in the array. - -sizeofArray# :: Array# a -> Int# -sizeofArray# = let x = x in x - --- |Return the number of elements in the array. - -sizeofMutableArray# :: MutableArray# s a -> Int# -sizeofMutableArray# = let x = x in x - --- |Read from specified index of immutable array. Result is packaged into --- an unboxed singleton; the result itself is not yet evaluated. - -indexArray# :: Array# a -> Int# -> (# a #) -indexArray# = let x = x in x - --- |Make a mutable array immutable, without copying. - -unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s,Array# a #) -unsafeFreezeArray# = let x = x in x - --- |Make an immutable array mutable, without copying. - -unsafeThawArray# :: Array# a -> State# s -> (# State# s,MutableArray# s a #) -unsafeThawArray# = let x = x in x - --- |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. - -copyArray# :: Array# a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s -copyArray# = let x = x in x - --- |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. - -copyMutableArray# :: MutableArray# s a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s -copyMutableArray# = let x = x in x - --- |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. - -cloneArray# :: Array# a -> Int# -> Int# -> Array# a -cloneArray# = let x = x in x - --- |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# s a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #) -cloneMutableArray# = let x = x in x - --- |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# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #) -freezeArray# = let x = x in x - --- |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# s -> (# State# s,MutableArray# s a #) -thawArray# = let x = x in x - --- |Unsafe, machine-level atomic compare and swap on an element within an Array. - -casArray# :: MutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #) -casArray# = let x = x in x - -data SmallArray# a - -data SmallMutableArray# s 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. - -newSmallArray# :: Int# -> a -> State# s -> (# State# s,SmallMutableArray# s a #) -newSmallArray# = let x = x in x - -sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int# -sameSmallMutableArray# = let x = x in x - --- |Read from specified index of mutable array. Result is not yet evaluated. - -readSmallArray# :: SmallMutableArray# s a -> Int# -> State# s -> (# State# s,a #) -readSmallArray# = let x = x in x - --- |Write to specified index of mutable array. - -writeSmallArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> State# s -writeSmallArray# = let x = x in x - --- |Return the number of elements in the array. - -sizeofSmallArray# :: SmallArray# a -> Int# -sizeofSmallArray# = let x = x in x - --- |Return the number of elements in the array. - -sizeofSmallMutableArray# :: SmallMutableArray# s a -> Int# -sizeofSmallMutableArray# = let x = x in x - --- |Read from specified index of immutable array. Result is packaged into --- an unboxed singleton; the result itself is not yet evaluated. - -indexSmallArray# :: SmallArray# a -> Int# -> (# a #) -indexSmallArray# = let x = x in x - --- |Make a mutable array immutable, without copying. - -unsafeFreezeSmallArray# :: SmallMutableArray# s a -> State# s -> (# State# s,SmallArray# a #) -unsafeFreezeSmallArray# = let x = x in x - --- |Make an immutable array mutable, without copying. - -unsafeThawSmallArray# :: SmallArray# a -> State# s -> (# State# s,SmallMutableArray# s a #) -unsafeThawSmallArray# = let x = x in x - --- |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. - -copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s -copySmallArray# = let x = x in x - --- |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. - -copySmallMutableArray# :: SmallMutableArray# s a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s -copySmallMutableArray# = let x = x in x - --- |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. - -cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a -cloneSmallArray# = let x = x in x - --- |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# s a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #) -cloneSmallMutableArray# = let x = x in x - --- |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# s a -> Int# -> Int# -> State# s -> (# State# s,SmallArray# a #) -freezeSmallArray# = let x = x in x - --- |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# s -> (# State# s,SmallMutableArray# s a #) -thawSmallArray# = let x = x in x - --- |Unsafe, machine-level atomic compare and swap on an element within an array. - -casSmallArray# :: SmallMutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #) -casSmallArray# = let x = x in x - -data ByteArray# - -data MutableByteArray# s - --- |Create a new mutable byte array of specified size (in bytes), in --- the specified state thread. - -newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) -newByteArray# = let x = x in x - --- |Create a mutable byte array that the GC guarantees not to move. - -newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) -newPinnedByteArray# = let x = x in x - --- |Create a mutable byte array, aligned by the specified amount, that the GC guarantees not to move. - -newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s,MutableByteArray# s #) -newAlignedPinnedByteArray# = let x = x in x - --- |Intended for use with pinned arrays; otherwise very unsafe! - -byteArrayContents# :: ByteArray# -> Addr# -byteArrayContents# = let x = x in x - -sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int# -sameMutableByteArray# = let x = x in x - --- |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 by @sizeofMutableArray\#@. - -shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s -shrinkMutableByteArray# = let x = x in x - --- |Resize (unpinned) mutable byte array to new specified size (in bytes). --- The returned @MutableByteArray\#@ is either the original --- @MutableByteArray\#@ resized in-place or, if not possible, a newly --- allocated (unpinned) @MutableByteArray\#@ (with the original content --- copied over). --- --- To avoid undefined behaviour, the original @MutableByteArray\#@ shall --- not be accessed anymore after a @resizeMutableByteArray\#@ has been --- performed. Moreover, no reference to the old one should be kept in order --- to allow garbage collection of the original @MutableByteArray\#@ in --- case a new @MutableByteArray\#@ had to be allocated. - -resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #) -resizeMutableByteArray# = let x = x in x - --- |Make a mutable byte array immutable, without copying. - -unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #) -unsafeFreezeByteArray# = let x = x in x - --- |Return the size of the array in bytes. - -sizeofByteArray# :: ByteArray# -> Int# -sizeofByteArray# = let x = x in x - --- |Return the size of the array in bytes. - -sizeofMutableByteArray# :: MutableByteArray# s -> Int# -sizeofMutableByteArray# = let x = x in x - --- |Read 8-bit character; offset in bytes. - -indexCharArray# :: ByteArray# -> Int# -> Char# -indexCharArray# = let x = x in x - --- |Read 31-bit character; offset in 4-byte words. - -indexWideCharArray# :: ByteArray# -> Int# -> Char# -indexWideCharArray# = let x = x in x - -indexIntArray# :: ByteArray# -> Int# -> Int# -indexIntArray# = let x = x in x - -indexWordArray# :: ByteArray# -> Int# -> Word# -indexWordArray# = let x = x in x - -indexAddrArray# :: ByteArray# -> Int# -> Addr# -indexAddrArray# = let x = x in x - -indexFloatArray# :: ByteArray# -> Int# -> Float# -indexFloatArray# = let x = x in x - -indexDoubleArray# :: ByteArray# -> Int# -> Double# -indexDoubleArray# = let x = x in x - -indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a -indexStablePtrArray# = let x = x in x - --- |Read 8-bit integer; offset in bytes. - -indexInt8Array# :: ByteArray# -> Int# -> Int# -indexInt8Array# = let x = x in x - --- |Read 16-bit integer; offset in 16-bit words. - -indexInt16Array# :: ByteArray# -> Int# -> Int# -indexInt16Array# = let x = x in x - --- |Read 32-bit integer; offset in 32-bit words. - -indexInt32Array# :: ByteArray# -> Int# -> Int# -indexInt32Array# = let x = x in x - --- |Read 64-bit integer; offset in 64-bit words. - -indexInt64Array# :: ByteArray# -> Int# -> Int# -indexInt64Array# = let x = x in x - --- |Read 8-bit word; offset in bytes. - -indexWord8Array# :: ByteArray# -> Int# -> Word# -indexWord8Array# = let x = x in x - --- |Read 16-bit word; offset in 16-bit words. - -indexWord16Array# :: ByteArray# -> Int# -> Word# -indexWord16Array# = let x = x in x - --- |Read 32-bit word; offset in 32-bit words. - -indexWord32Array# :: ByteArray# -> Int# -> Word# -indexWord32Array# = let x = x in x - --- |Read 64-bit word; offset in 64-bit words. - -indexWord64Array# :: ByteArray# -> Int# -> Word# -indexWord64Array# = let x = x in x - --- |Read 8-bit character; offset in bytes. - -readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) -readCharArray# = let x = x in x - --- |Read 31-bit character; offset in 4-byte words. - -readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) -readWideCharArray# = let x = x in x - --- |Read intger; offset in words. - -readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readIntArray# = let x = x in x - --- |Read word; offset in words. - -readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -readWordArray# = let x = x in x - -readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #) -readAddrArray# = let x = x in x - -readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #) -readFloatArray# = let x = x in x - -readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #) -readDoubleArray# = let x = x in x - -readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #) -readStablePtrArray# = let x = x in x - -readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readInt8Array# = let x = x in x - -readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readInt16Array# = let x = x in x - -readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readInt32Array# = let x = x in x - -readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -readInt64Array# = let x = x in x - -readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -readWord8Array# = let x = x in x - -readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -readWord16Array# = let x = x in x - -readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -readWord32Array# = let x = x in x - -readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) -readWord64Array# = let x = x in x - --- |Write 8-bit character; offset in bytes. - -writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s -writeCharArray# = let x = x in x - --- |Write 31-bit character; offset in 4-byte words. - -writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s -writeWideCharArray# = let x = x in x - -writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeIntArray# = let x = x in x - -writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s -writeWordArray# = let x = x in x - -writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s -writeAddrArray# = let x = x in x - -writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s -writeFloatArray# = let x = x in x - -writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s -writeDoubleArray# = let x = x in x - -writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s -writeStablePtrArray# = let x = x in x - -writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeInt8Array# = let x = x in x - -writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeInt16Array# = let x = x in x - -writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeInt32Array# = let x = x in x - -writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -writeInt64Array# = let x = x in x - -writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s -writeWord8Array# = let x = x in x - -writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s -writeWord16Array# = let x = x in x - -writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s -writeWord32Array# = let x = x in x - -writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s -writeWord64Array# = let x = x in x - --- |Copy a range of the ByteArray# to the specified region in the MutableByteArray#. --- 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. - -copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -copyByteArray# = let x = x in x - --- |Copy a range of the first MutableByteArray# to the specified region in the second MutableByteArray#. --- Both arrays must fully contain the specified ranges, but this is not checked. - -copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -copyMutableByteArray# = let x = x in x - --- |Copy a range of the ByteArray# to the memory range starting at the Addr#. --- The ByteArray# and the memory region at Addr# must fully contain the --- specified ranges, but this is not checked. The Addr# must not point into the --- ByteArray# (e.g. if the ByteArray# were pinned), but this is not checked --- either. - -copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s -copyByteArrayToAddr# = let x = x in x - --- |Copy a range of the MutableByteArray# to the memory range starting at the --- Addr#. The MutableByteArray# and the memory region at Addr# must fully --- contain the specified ranges, but this is not checked. The Addr# must not --- point into the MutableByteArray# (e.g. if the MutableByteArray# were --- pinned), but this is not checked either. - -copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s -copyMutableByteArrayToAddr# = let x = x in x - --- |Copy a memory range starting at the Addr# to the specified range in the --- MutableByteArray#. The memory region at Addr# and the ByteArray# must fully --- contain the specified ranges, but this is not checked. The Addr# must not --- point into the MutableByteArray# (e.g. if the MutableByteArray# were pinned), --- but this is not checked either. - -copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -copyAddrToByteArray# = let x = x in x - --- |Set the range of the MutableByteArray# to the specified character. - -setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s -setByteArray# = let x = x in x - --- |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. - -atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) -atomicReadIntArray# = let x = x in x - --- |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. - -atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s -atomicWriteIntArray# = let x = x in x - --- |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. - -casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #) -casIntArray# = let x = x in x - --- |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. - -fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchAddIntArray# = let x = x in x - --- |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. - -fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchSubIntArray# = let x = x in x - --- |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. - -fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchAndIntArray# = let x = x in x - --- |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. - -fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchNandIntArray# = let x = x in x - --- |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. - -fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchOrIntArray# = let x = x in x - --- |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. - -fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) -fetchXorIntArray# = let x = x in x - -data ArrayArray# - -data MutableArrayArray# s - --- |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. - -newArrayArray# :: Int# -> State# s -> (# State# s,MutableArrayArray# s #) -newArrayArray# = let x = x in x - -sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int# -sameMutableArrayArray# = let x = x in x - --- |Make a mutable array of arrays immutable, without copying. - -unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s,ArrayArray# #) -unsafeFreezeArrayArray# = let x = x in x - --- |Return the number of elements in the array. - -sizeofArrayArray# :: ArrayArray# -> Int# -sizeofArrayArray# = let x = x in x - --- |Return the number of elements in the array. - -sizeofMutableArrayArray# :: MutableArrayArray# s -> Int# -sizeofMutableArrayArray# = let x = x in x - -indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray# -indexByteArrayArray# = let x = x in x - -indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray# -indexArrayArrayArray# = let x = x in x - -readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ByteArray# #) -readByteArrayArray# = let x = x in x - -readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #) -readMutableByteArrayArray# = let x = x in x - -readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ArrayArray# #) -readArrayArrayArray# = let x = x in x - -readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableArrayArray# s #) -readMutableArrayArrayArray# = let x = x in x - -writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s -writeByteArrayArray# = let x = x in x - -writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s -writeMutableByteArrayArray# = let x = x in x - -writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s -writeArrayArrayArray# = let x = x in x - -writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s -writeMutableArrayArrayArray# = let x = x in x - --- |Copy a range of the ArrayArray# to the specified region in the MutableArrayArray#. --- 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. - -copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s -copyArrayArray# = let x = x in x - --- |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. - -copyMutableArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s -copyMutableArrayArray# = let x = x in x - --- | An arbitrary machine address assumed to point outside --- the garbage-collected heap. - -data Addr# - --- | The null address. - -nullAddr# :: Addr# -nullAddr# = let x = x in x - -plusAddr# :: Addr# -> Int# -> Addr# -plusAddr# = let x = x in x - --- |Result is meaningless if two @Addr\#@s are so far apart that their --- difference doesn\'t fit in an @Int\#@. - -minusAddr# :: Addr# -> Addr# -> Int# -minusAddr# = let x = x in x - --- |Return the remainder when the @Addr\#@ arg, treated like an @Int\#@, --- is divided by the @Int\#@ arg. - -remAddr# :: Addr# -> Int# -> Int# -remAddr# = let x = x in x - --- |Coerce directly from address to int. Strongly deprecated. - -addr2Int# :: Addr# -> Int# -addr2Int# = let x = x in x - --- |Coerce directly from int to address. Strongly deprecated. - -int2Addr# :: Int# -> Addr# -int2Addr# = let x = x in x - -gtAddr# :: Addr# -> Addr# -> Int# -gtAddr# = let x = x in x - -geAddr# :: Addr# -> Addr# -> Int# -geAddr# = let x = x in x - -eqAddr# :: Addr# -> Addr# -> Int# -eqAddr# = let x = x in x - -neAddr# :: Addr# -> Addr# -> Int# -neAddr# = let x = x in x - -ltAddr# :: Addr# -> Addr# -> Int# -ltAddr# = let x = x in x - -leAddr# :: Addr# -> Addr# -> Int# -leAddr# = let x = x in x - --- |Reads 8-bit character; offset in bytes. - -indexCharOffAddr# :: Addr# -> Int# -> Char# -indexCharOffAddr# = let x = x in x - --- |Reads 31-bit character; offset in 4-byte words. - -indexWideCharOffAddr# :: Addr# -> Int# -> Char# -indexWideCharOffAddr# = let x = x in x - -indexIntOffAddr# :: Addr# -> Int# -> Int# -indexIntOffAddr# = let x = x in x - -indexWordOffAddr# :: Addr# -> Int# -> Word# -indexWordOffAddr# = let x = x in x - -indexAddrOffAddr# :: Addr# -> Int# -> Addr# -indexAddrOffAddr# = let x = x in x - -indexFloatOffAddr# :: Addr# -> Int# -> Float# -indexFloatOffAddr# = let x = x in x - -indexDoubleOffAddr# :: Addr# -> Int# -> Double# -indexDoubleOffAddr# = let x = x in x - -indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -indexStablePtrOffAddr# = let x = x in x - -indexInt8OffAddr# :: Addr# -> Int# -> Int# -indexInt8OffAddr# = let x = x in x - -indexInt16OffAddr# :: Addr# -> Int# -> Int# -indexInt16OffAddr# = let x = x in x - -indexInt32OffAddr# :: Addr# -> Int# -> Int# -indexInt32OffAddr# = let x = x in x - -indexInt64OffAddr# :: Addr# -> Int# -> Int# -indexInt64OffAddr# = let x = x in x - -indexWord8OffAddr# :: Addr# -> Int# -> Word# -indexWord8OffAddr# = let x = x in x - -indexWord16OffAddr# :: Addr# -> Int# -> Word# -indexWord16OffAddr# = let x = x in x - -indexWord32OffAddr# :: Addr# -> Int# -> Word# -indexWord32OffAddr# = let x = x in x - -indexWord64OffAddr# :: Addr# -> Int# -> Word# -indexWord64OffAddr# = let x = x in x - --- |Reads 8-bit character; offset in bytes. - -readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #) -readCharOffAddr# = let x = x in x - --- |Reads 31-bit character; offset in 4-byte words. - -readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #) -readWideCharOffAddr# = let x = x in x - -readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) -readIntOffAddr# = let x = x in x - -readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) -readWordOffAddr# = let x = x in x - -readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #) -readAddrOffAddr# = let x = x in x - -readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #) -readFloatOffAddr# = let x = x in x - -readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #) -readDoubleOffAddr# = let x = x in x - -readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #) -readStablePtrOffAddr# = let x = x in x - -readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) -readInt8OffAddr# = let x = x in x - -readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) -readInt16OffAddr# = let x = x in x - -readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) -readInt32OffAddr# = let x = x in x - -readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) -readInt64OffAddr# = let x = x in x - -readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) -readWord8OffAddr# = let x = x in x - -readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) -readWord16OffAddr# = let x = x in x - -readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) -readWord32OffAddr# = let x = x in x - -readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) -readWord64OffAddr# = let x = x in x - -writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s -writeCharOffAddr# = let x = x in x - -writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s -writeWideCharOffAddr# = let x = x in x - -writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s -writeIntOffAddr# = let x = x in x - -writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s -writeWordOffAddr# = let x = x in x - -writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s -writeAddrOffAddr# = let x = x in x - -writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s -writeFloatOffAddr# = let x = x in x - -writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s -writeDoubleOffAddr# = let x = x in x - -writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s -writeStablePtrOffAddr# = let x = x in x - -writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s -writeInt8OffAddr# = let x = x in x - -writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s -writeInt16OffAddr# = let x = x in x - -writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s -writeInt32OffAddr# = let x = x in x - -writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s -writeInt64OffAddr# = let x = x in x - -writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s -writeWord8OffAddr# = let x = x in x - -writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s -writeWord16OffAddr# = let x = x in x - -writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s -writeWord32OffAddr# = let x = x in x - -writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s -writeWord64OffAddr# = let x = x in x - --- |A @MutVar\#@ behaves like a single-element mutable array. - -data MutVar# s a - --- |Create @MutVar\#@ with specified initial value in specified state thread. - -newMutVar# :: a -> State# s -> (# State# s,MutVar# s a #) -newMutVar# = let x = x in x - --- |Read contents of @MutVar\#@. Result is not yet evaluated. - -readMutVar# :: MutVar# s a -> State# s -> (# State# s,a #) -readMutVar# = let x = x in x - --- |Write contents of @MutVar\#@. - -writeMutVar# :: MutVar# s a -> a -> State# s -> State# s -writeMutVar# = let x = x in x - -sameMutVar# :: MutVar# s a -> MutVar# s a -> Int# -sameMutVar# = let x = x in x - -atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s,c #) -atomicModifyMutVar# = let x = x in x - -casMutVar# :: MutVar# s a -> a -> a -> State# s -> (# State# s,Int#,a #) -casMutVar# = let x = x in x - -catch# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) -catch# = let x = x in x - -raise# :: a -> b -raise# = let x = x in x - -raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld),b #) -raiseIO# = let x = x in x - -maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) -maskAsyncExceptions# = let x = x in x - -maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) -maskUninterruptible# = let x = x in x - -unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) -unmaskAsyncExceptions# = let x = x in x - -getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #) -getMaskingState# = let x = x in x - -data TVar# s a - -atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) -atomically# = let x = x in x - -retry# :: State# (RealWorld) -> (# State# (RealWorld),a #) -retry# = let x = x in x - -catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) -catchRetry# = let x = x in x - -catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) -catchSTM# = let x = x in x - -check# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),() #) -check# = let x = x in x - --- |Create a new @TVar\#@ holding a specified initial value. - -newTVar# :: a -> State# s -> (# State# s,TVar# s a #) -newTVar# = let x = x in x - --- |Read contents of @TVar\#@. Result is not yet evaluated. - -readTVar# :: TVar# s a -> State# s -> (# State# s,a #) -readTVar# = let x = x in x - --- |Read contents of @TVar\#@ outside an STM transaction - -readTVarIO# :: TVar# s a -> State# s -> (# State# s,a #) -readTVarIO# = let x = x in x - --- |Write contents of @TVar\#@. - -writeTVar# :: TVar# s a -> a -> State# s -> State# s -writeTVar# = let x = x in x - -sameTVar# :: TVar# s a -> TVar# s a -> Int# -sameTVar# = let x = x in x - --- | A shared mutable variable (/not/ the same as a @MutVar\#@!). --- (Note: in a non-concurrent implementation, @(MVar\# a)@ can be --- represented by @(MutVar\# (Maybe a))@.) - -data MVar# s a - --- |Create new @MVar\#@; initially empty. - -newMVar# :: State# s -> (# State# s,MVar# s a #) -newMVar# = let x = x in x - --- |If @MVar\#@ is empty, block until it becomes full. --- Then remove and return its contents, and set it empty. - -takeMVar# :: MVar# s a -> State# s -> (# State# s,a #) -takeMVar# = let x = x in x - --- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined. --- Otherwise, return with integer 1 and contents of @MVar\#@, and set @MVar\#@ empty. - -tryTakeMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #) -tryTakeMVar# = let x = x in x - --- |If @MVar\#@ is full, block until it becomes empty. --- Then store value arg as its new contents. - -putMVar# :: MVar# s a -> a -> State# s -> State# s -putMVar# = let x = x in x - --- |If @MVar\#@ is full, immediately return with integer 0. --- Otherwise, store value arg as @MVar\#@\'s new contents, and return with integer 1. - -tryPutMVar# :: MVar# s a -> a -> State# s -> (# State# s,Int# #) -tryPutMVar# = let x = x in x - --- |If @MVar\#@ is empty, block until it becomes full. --- Then read its contents without modifying the MVar, without possibility --- of intervention from other threads. - -readMVar# :: MVar# s a -> State# s -> (# State# s,a #) -readMVar# = let x = x in x - --- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined. --- Otherwise, return with integer 1 and contents of @MVar\#@. - -tryReadMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #) -tryReadMVar# = let x = x in x - -sameMVar# :: MVar# s a -> MVar# s a -> Int# -sameMVar# = let x = x in x - --- |Return 1 if @MVar\#@ is empty; 0 otherwise. - -isEmptyMVar# :: MVar# s a -> State# s -> (# State# s,Int# #) -isEmptyMVar# = let x = x in x - --- |Sleep specified number of microseconds. - -delay# :: Int# -> State# s -> State# s -delay# = let x = x in x - --- |Block until input is available on specified file descriptor. - -waitRead# :: Int# -> State# s -> State# s -waitRead# = let x = x in x - --- |Block until output is possible on specified file descriptor. - -waitWrite# :: Int# -> State# s -> State# s -waitWrite# = let x = x in x - --- | @State\#@ is the primitive, unlifted type of states. It has --- one type parameter, thus @State\# RealWorld@, or @State\# s@, --- where s is a type variable. The only purpose of the type parameter --- is to keep different state threads separate. It is represented by --- nothing at all. - -data State# s - --- | @RealWorld@ is deeply magical. It is /primitive/, but it is not --- /unlifted/ (hence @ptrArg@). We never manipulate values of type --- @RealWorld@; it\'s only used in the type system, to parameterise @State\#@. - -data RealWorld - --- |(In a non-concurrent implementation, this can be a singleton --- type, whose (unique) value is returned by @myThreadId\#@. The --- other operations can be omitted.) - -data ThreadId# - -fork# :: a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) -fork# = let x = x in x - -forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) -forkOn# = let x = x in x - -killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld) -killThread# = let x = x in x - -yield# :: State# (RealWorld) -> State# (RealWorld) -yield# = let x = x in x - -myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) -myThreadId# = let x = x in x - -labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld) -labelThread# = let x = x in x - -isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #) -isCurrentThreadBound# = let x = x in x - -noDuplicate# :: State# (RealWorld) -> State# (RealWorld) -noDuplicate# = let x = x in x - -threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #) -threadStatus# = let x = x in x - -data Weak# b - -mkWeak# :: o -> b -> c -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #) -mkWeak# = let x = x in x - -mkWeakNoFinalizer# :: o -> b -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #) -mkWeakNoFinalizer# = let x = x in x - --- | @addCFinalizerToWeak# fptr ptr flag eptr w@ attaches a C --- function pointer @fptr@ to a weak pointer @w@ as a finalizer. If --- @flag@ is zero, @fptr@ will be called with one argument, --- @ptr@. Otherwise, it will be called with two arguments, --- @eptr@ and @ptr@. @addCFinalizerToWeak#@ returns --- 1 on success, or 0 if @w@ is already dead. - -addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# (RealWorld) -> (# State# (RealWorld),Int# #) -addCFinalizerToWeak# = let x = x in x - -deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,a #) -deRefWeak# = let x = x in x - -finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),() #) #) -finalizeWeak# = let x = x in x - -touch# :: o -> State# (RealWorld) -> State# (RealWorld) -touch# = let x = x in x - -data StablePtr# a - -data StableName# a - -makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a #) -makeStablePtr# = let x = x in x - -deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld),a #) -deRefStablePtr# = let x = x in x - -eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int# -eqStablePtr# = let x = x in x - -makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld),StableName# a #) -makeStableName# = let x = x in x - -eqStableName# :: StableName# a -> StableName# b -> Int# -eqStableName# = let x = x in x - -stableNameToInt# :: StableName# a -> Int# -stableNameToInt# = let x = x in x - -reallyUnsafePtrEquality# :: a -> a -> Int# -reallyUnsafePtrEquality# = let x = x in x - -par# :: a -> Int# -par# = let x = x in x - -spark# :: a -> State# s -> (# State# s,a #) -spark# = let x = x in x - -seq# :: a -> State# s -> (# State# s,a #) -seq# = let x = x in x - -getSpark# :: State# s -> (# State# s,Int#,a #) -getSpark# = let x = x in x - --- | Returns the number of sparks in the local spark pool. - -numSparks# :: State# s -> (# State# s,Int# #) -numSparks# = let x = x in x - -parGlobal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int# -parGlobal# = let x = x in x - -parLocal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int# -parLocal# = let x = x in x - -parAt# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int# -parAt# = let x = x in x - -parAtAbs# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int# -parAtAbs# = let x = x in x - -parAtRel# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int# -parAtRel# = let x = x in x - -parAtForNow# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int# -parAtForNow# = let x = x in x - -dataToTag# :: a -> Int# -dataToTag# = let x = x in x - -tagToEnum# :: Int# -> a -tagToEnum# = let x = x in x - --- |Primitive bytecode type. - -data BCO# - --- |Convert an @Addr\#@ to a followable Any type. - -addrToAny# :: Addr# -> (# a #) -addrToAny# = let x = x in x - -mkApUpd0# :: BCO# -> (# a #) -mkApUpd0# = let x = x in x - -newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO# #) -newBCO# = let x = x in x - -unpackClosure# :: a -> (# Addr#,Array# b,ByteArray# #) -unpackClosure# = let x = x in x - -getApStackVal# :: a -> Int# -> (# Int#,b #) -getApStackVal# = let x = x in x - -getCCSOf# :: a -> State# s -> (# State# s,Addr# #) -getCCSOf# = let x = x in x - --- | Returns the current @CostCentreStack@ (value is @NULL@ if --- not profiling). Takes a dummy argument which can be used to --- avoid the call to @getCCCS\#@ being floated out by the --- simplifier, which would result in an uninformative stack --- (\"CAF\"). - -getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #) -getCurrentCCS# = let x = x in x - --- | The type constructor @Proxy#@ is used to bear witness to some --- type variable. It\'s used when you want to pass around proxy values --- for doing things like modelling type applications. A @Proxy#@ --- is not only unboxed, it also has a polymorphic kind, and has no --- runtime representation, being totally free. - -data Proxy# a - --- | Witness for an unboxed @Proxy#@ value, which has no runtime --- representation. - -proxy# :: Proxy# a -proxy# = let x = x in x - --- | The value of @seq a b@ is bottom if @a@ is bottom, and --- otherwise equal to @b@. @seq@ is usually introduced to --- improve performance by avoiding unneeded laziness. --- --- A note on evaluation order: the expression @seq a b@ does --- /not/ guarantee that @a@ will be evaluated before @b@. --- The only guarantee given by @seq@ is that the both @a@ --- and @b@ will be evaluated before @seq@ returns a value. --- In particular, this means that @b@ may be evaluated before --- @a@. If you need to guarantee a specific order of evaluation, --- you must use the function @pseq@ from the \"parallel\" package. - -seq :: a -> b -> b -seq = let x = x in x - --- | The type constructor @Any@ is type to which you can unsafely coerce any --- lifted type, and back. --- --- * It is lifted, and hence represented by a pointer --- --- * It does not claim to be a /data/ type, and that\'s important for --- the code generator, because the code gen may /enter/ a data value --- but never enters a function value. --- --- It\'s also used to instantiate un-constrained type variables after type --- checking. For example, @length@ has type --- --- @length :: forall a. [a] -> Int@ --- --- and the list datacon for the empty list has type --- --- @[] :: forall a. [a]@ --- --- In order to compose these two terms as @length []@ a type --- application is required, but there is no constraint on the --- choice. In this situation GHC uses @Any@: --- --- @length (Any *) ([] (Any *))@ --- --- Above, we print kinds explicitly, as if with --- @-fprint-explicit-kinds@. --- --- Note that @Any@ is kind polymorphic; its kind is thus --- @forall k. k@. - -data Any - --- | The kind @AnyK@ is the kind level counterpart to @Any@. In a --- kind polymorphic setting, a similar example to the length of the empty --- list can be given at the type level: --- --- @type family Length (l :: [k]) :: Nat@ --- @type instance Length [] = Zero@ --- --- When @Length@ is applied to the empty (promoted) list it will have --- the kind @Length AnyK []@. --- --- @AnyK@ is currently not exported and cannot be used directly, but --- you might see it in debug output from the compiler. --- - -data AnyK - --- | The function @unsafeCoerce\#@ allows you to side-step the typechecker entirely. That --- is, it allows you to coerce any type into any other type. If you use this function, --- you had better get it right, otherwise segmentation faults await. It is generally --- used when you want to write a program that you know is well-typed, but where Haskell\'s --- type system is not expressive enough to prove that it is well typed. --- --- The following uses of @unsafeCoerce\#@ are supposed to work (i.e. not lead to --- spurious compile-time or run-time crashes): --- --- * Casting any lifted type to @Any@ --- --- * Casting @Any@ back to the real type --- --- * Casting an unboxed type to another unboxed type of the same size --- (but not coercions between floating-point and integral types) --- --- * Casting between two types that have the same runtime representation. One case is when --- the two types differ only in \"phantom\" type parameters, for example --- @Ptr Int@ to @Ptr Float@, or @[Int]@ to @[Float]@ when the list is --- known to be empty. Also, a @newtype@ of a type @T@ has the same representation --- at runtime as @T@. --- --- Other uses of @unsafeCoerce\#@ are undefined. In particular, you should not use --- @unsafeCoerce\#@ to cast a T to an algebraic data type D, unless T is also --- an algebraic data type. For example, do not cast @Int->Int@ to @Bool@, even if --- you later cast that @Bool@ back to @Int->Int@ before applying it. The reasons --- have to do with GHC\'s internal representation details (for the congnoscenti, data values --- can be entered but function closures cannot). If you want a safe type to cast things --- to, use @Any@, which is not an algebraic data type. --- --- - -unsafeCoerce# :: a -> b -unsafeCoerce# = let x = x in x - --- | 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. - -traceEvent# :: Addr# -> State# s -> State# s -traceEvent# = let x = x in x - --- | 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. - -traceMarker# :: Addr# -> State# s -> State# s -traceMarker# = let x = x in x - --- | The function @coerce@ 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. --- - -coerce :: Coercible a b => a -> b -coerce = let x = x in x - -data Int8X16# - -data Int16X8# - -data Int32X4# - -data Int64X2# - -data Int8X32# - -data Int16X16# - -data Int32X8# - -data Int64X4# - -data Int8X64# - -data Int16X32# - -data Int32X16# - -data Int64X8# - -data Word8X16# - -data Word16X8# - -data Word32X4# - -data Word64X2# - -data Word8X32# - -data Word16X16# - -data Word32X8# - -data Word64X4# - -data Word8X64# - -data Word16X32# - -data Word32X16# - -data Word64X8# - -data FloatX4# - -data DoubleX2# - -data FloatX8# - -data DoubleX4# - -data FloatX16# - -data DoubleX8# - --- | Broadcast a scalar to all elements of a vector. - -broadcastInt8X16# :: Int# -> Int8X16# -broadcastInt8X16# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastInt16X8# :: Int# -> Int16X8# -broadcastInt16X8# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastInt32X4# :: Int# -> Int32X4# -broadcastInt32X4# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastInt64X2# :: Int# -> Int64X2# -broadcastInt64X2# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastInt8X32# :: Int# -> Int8X32# -broadcastInt8X32# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastInt16X16# :: Int# -> Int16X16# -broadcastInt16X16# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastInt32X8# :: Int# -> Int32X8# -broadcastInt32X8# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastInt64X4# :: Int# -> Int64X4# -broadcastInt64X4# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastInt8X64# :: Int# -> Int8X64# -broadcastInt8X64# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastInt16X32# :: Int# -> Int16X32# -broadcastInt16X32# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastInt32X16# :: Int# -> Int32X16# -broadcastInt32X16# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastInt64X8# :: Int# -> Int64X8# -broadcastInt64X8# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastWord8X16# :: Word# -> Word8X16# -broadcastWord8X16# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastWord16X8# :: Word# -> Word16X8# -broadcastWord16X8# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastWord32X4# :: Word# -> Word32X4# -broadcastWord32X4# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastWord64X2# :: Word# -> Word64X2# -broadcastWord64X2# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastWord8X32# :: Word# -> Word8X32# -broadcastWord8X32# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastWord16X16# :: Word# -> Word16X16# -broadcastWord16X16# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastWord32X8# :: Word# -> Word32X8# -broadcastWord32X8# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastWord64X4# :: Word# -> Word64X4# -broadcastWord64X4# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastWord8X64# :: Word# -> Word8X64# -broadcastWord8X64# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastWord16X32# :: Word# -> Word16X32# -broadcastWord16X32# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastWord32X16# :: Word# -> Word32X16# -broadcastWord32X16# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastWord64X8# :: Word# -> Word64X8# -broadcastWord64X8# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastFloatX4# :: Float# -> FloatX4# -broadcastFloatX4# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastDoubleX2# :: Double# -> DoubleX2# -broadcastDoubleX2# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastFloatX8# :: Float# -> FloatX8# -broadcastFloatX8# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastDoubleX4# :: Double# -> DoubleX4# -broadcastDoubleX4# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastFloatX16# :: Float# -> FloatX16# -broadcastFloatX16# = let x = x in x - --- | Broadcast a scalar to all elements of a vector. - -broadcastDoubleX8# :: Double# -> DoubleX8# -broadcastDoubleX8# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packInt8X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X16# -packInt8X16# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packInt16X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X8# -packInt16X8# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packInt32X4# :: (# Int#,Int#,Int#,Int# #) -> Int32X4# -packInt32X4# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packInt64X2# :: (# Int#,Int# #) -> Int64X2# -packInt64X2# = let x = x in x - --- | 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# -packInt8X32# = let x = x in x - --- | 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# -packInt16X16# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packInt32X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int32X8# -packInt32X8# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packInt64X4# :: (# Int#,Int#,Int#,Int# #) -> Int64X4# -packInt64X4# = let x = x in x - --- | 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# -packInt8X64# = let x = x in x - --- | 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# -packInt16X32# = let x = x in x - --- | 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# -packInt32X16# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packInt64X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int64X8# -packInt64X8# = let x = x in x - --- | 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# -packWord8X16# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packWord16X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X8# -packWord16X8# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packWord32X4# :: (# Word#,Word#,Word#,Word# #) -> Word32X4# -packWord32X4# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packWord64X2# :: (# Word#,Word# #) -> Word64X2# -packWord64X2# = let x = x in x - --- | 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# -packWord8X32# = let x = x in x - --- | 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# -packWord16X16# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packWord32X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word32X8# -packWord32X8# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packWord64X4# :: (# Word#,Word#,Word#,Word# #) -> Word64X4# -packWord64X4# = let x = x in x - --- | 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# -packWord8X64# = let x = x in x - --- | 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# -packWord16X32# = let x = x in x - --- | 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# -packWord32X16# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packWord64X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word64X8# -packWord64X8# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packFloatX4# :: (# Float#,Float#,Float#,Float# #) -> FloatX4# -packFloatX4# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packDoubleX2# :: (# Double#,Double# #) -> DoubleX2# -packDoubleX2# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packFloatX8# :: (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -> FloatX8# -packFloatX8# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packDoubleX4# :: (# Double#,Double#,Double#,Double# #) -> DoubleX4# -packDoubleX4# = let x = x in x - --- | 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# -packFloatX16# = let x = x in x - --- | Pack the elements of an unboxed tuple into a vector. - -packDoubleX8# :: (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #) -> DoubleX8# -packDoubleX8# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackInt8X16# :: Int8X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -unpackInt8X16# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackInt16X8# :: Int16X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -unpackInt16X8# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackInt32X4# :: Int32X4# -> (# Int#,Int#,Int#,Int# #) -unpackInt32X4# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackInt64X2# :: Int64X2# -> (# Int#,Int# #) -unpackInt64X2# = let x = x in x - --- | 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# #) -unpackInt8X32# = let x = x in x - --- | 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# #) -unpackInt16X16# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackInt32X8# :: Int32X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -unpackInt32X8# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackInt64X4# :: Int64X4# -> (# Int#,Int#,Int#,Int# #) -unpackInt64X4# = let x = x in x - --- | 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# #) -unpackInt8X64# = let x = x in x - --- | 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# #) -unpackInt16X32# = let x = x in x - --- | 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# #) -unpackInt32X16# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackInt64X8# :: Int64X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -unpackInt64X8# = let x = x in x - --- | 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# #) -unpackWord8X16# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackWord16X8# :: Word16X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -unpackWord16X8# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackWord32X4# :: Word32X4# -> (# Word#,Word#,Word#,Word# #) -unpackWord32X4# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackWord64X2# :: Word64X2# -> (# Word#,Word# #) -unpackWord64X2# = let x = x in x - --- | 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# #) -unpackWord8X32# = let x = x in x - --- | 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# #) -unpackWord16X16# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackWord32X8# :: Word32X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -unpackWord32X8# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackWord64X4# :: Word64X4# -> (# Word#,Word#,Word#,Word# #) -unpackWord64X4# = let x = x in x - --- | 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# #) -unpackWord8X64# = let x = x in x - --- | 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# #) -unpackWord16X32# = let x = x in x - --- | 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# #) -unpackWord32X16# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackWord64X8# :: Word64X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -unpackWord64X8# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackFloatX4# :: FloatX4# -> (# Float#,Float#,Float#,Float# #) -unpackFloatX4# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackDoubleX2# :: DoubleX2# -> (# Double#,Double# #) -unpackDoubleX2# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackFloatX8# :: FloatX8# -> (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -unpackFloatX8# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackDoubleX4# :: DoubleX4# -> (# Double#,Double#,Double#,Double# #) -unpackDoubleX4# = let x = x in x - --- | 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# #) -unpackFloatX16# = let x = x in x - --- | Unpack the elements of a vector into an unboxed tuple. # - -unpackDoubleX8# :: DoubleX8# -> (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #) -unpackDoubleX8# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertInt8X16# :: Int8X16# -> Int# -> Int# -> Int8X16# -insertInt8X16# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertInt16X8# :: Int16X8# -> Int# -> Int# -> Int16X8# -insertInt16X8# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertInt32X4# :: Int32X4# -> Int# -> Int# -> Int32X4# -insertInt32X4# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertInt64X2# :: Int64X2# -> Int# -> Int# -> Int64X2# -insertInt64X2# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertInt8X32# :: Int8X32# -> Int# -> Int# -> Int8X32# -insertInt8X32# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertInt16X16# :: Int16X16# -> Int# -> Int# -> Int16X16# -insertInt16X16# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertInt32X8# :: Int32X8# -> Int# -> Int# -> Int32X8# -insertInt32X8# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertInt64X4# :: Int64X4# -> Int# -> Int# -> Int64X4# -insertInt64X4# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertInt8X64# :: Int8X64# -> Int# -> Int# -> Int8X64# -insertInt8X64# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertInt16X32# :: Int16X32# -> Int# -> Int# -> Int16X32# -insertInt16X32# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertInt32X16# :: Int32X16# -> Int# -> Int# -> Int32X16# -insertInt32X16# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertInt64X8# :: Int64X8# -> Int# -> Int# -> Int64X8# -insertInt64X8# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertWord8X16# :: Word8X16# -> Word# -> Int# -> Word8X16# -insertWord8X16# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertWord16X8# :: Word16X8# -> Word# -> Int# -> Word16X8# -insertWord16X8# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertWord32X4# :: Word32X4# -> Word# -> Int# -> Word32X4# -insertWord32X4# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertWord64X2# :: Word64X2# -> Word# -> Int# -> Word64X2# -insertWord64X2# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertWord8X32# :: Word8X32# -> Word# -> Int# -> Word8X32# -insertWord8X32# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertWord16X16# :: Word16X16# -> Word# -> Int# -> Word16X16# -insertWord16X16# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertWord32X8# :: Word32X8# -> Word# -> Int# -> Word32X8# -insertWord32X8# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertWord64X4# :: Word64X4# -> Word# -> Int# -> Word64X4# -insertWord64X4# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertWord8X64# :: Word8X64# -> Word# -> Int# -> Word8X64# -insertWord8X64# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertWord16X32# :: Word16X32# -> Word# -> Int# -> Word16X32# -insertWord16X32# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertWord32X16# :: Word32X16# -> Word# -> Int# -> Word32X16# -insertWord32X16# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertWord64X8# :: Word64X8# -> Word# -> Int# -> Word64X8# -insertWord64X8# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4# -insertFloatX4# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2# -insertDoubleX2# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8# -insertFloatX8# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4# -insertDoubleX4# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16# -insertFloatX16# = let x = x in x - --- | Insert a scalar at the given position in a vector. - -insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8# -insertDoubleX8# = let x = x in x - --- | Add two vectors element-wise. - -plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# -plusInt8X16# = let x = x in x - --- | Add two vectors element-wise. - -plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# -plusInt16X8# = let x = x in x - --- | Add two vectors element-wise. - -plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# -plusInt32X4# = let x = x in x - --- | Add two vectors element-wise. - -plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# -plusInt64X2# = let x = x in x - --- | Add two vectors element-wise. - -plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# -plusInt8X32# = let x = x in x - --- | Add two vectors element-wise. - -plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# -plusInt16X16# = let x = x in x - --- | Add two vectors element-wise. - -plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# -plusInt32X8# = let x = x in x - --- | Add two vectors element-wise. - -plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# -plusInt64X4# = let x = x in x - --- | Add two vectors element-wise. - -plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# -plusInt8X64# = let x = x in x - --- | Add two vectors element-wise. - -plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# -plusInt16X32# = let x = x in x - --- | Add two vectors element-wise. - -plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# -plusInt32X16# = let x = x in x - --- | Add two vectors element-wise. - -plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# -plusInt64X8# = let x = x in x - --- | Add two vectors element-wise. - -plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# -plusWord8X16# = let x = x in x - --- | Add two vectors element-wise. - -plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# -plusWord16X8# = let x = x in x - --- | Add two vectors element-wise. - -plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# -plusWord32X4# = let x = x in x - --- | Add two vectors element-wise. - -plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# -plusWord64X2# = let x = x in x - --- | Add two vectors element-wise. - -plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# -plusWord8X32# = let x = x in x - --- | Add two vectors element-wise. - -plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# -plusWord16X16# = let x = x in x - --- | Add two vectors element-wise. - -plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# -plusWord32X8# = let x = x in x - --- | Add two vectors element-wise. - -plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# -plusWord64X4# = let x = x in x - --- | Add two vectors element-wise. - -plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# -plusWord8X64# = let x = x in x - --- | Add two vectors element-wise. - -plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# -plusWord16X32# = let x = x in x - --- | Add two vectors element-wise. - -plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# -plusWord32X16# = let x = x in x - --- | Add two vectors element-wise. - -plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# -plusWord64X8# = let x = x in x - --- | Add two vectors element-wise. - -plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -plusFloatX4# = let x = x in x - --- | Add two vectors element-wise. - -plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -plusDoubleX2# = let x = x in x - --- | Add two vectors element-wise. - -plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -plusFloatX8# = let x = x in x - --- | Add two vectors element-wise. - -plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -plusDoubleX4# = let x = x in x - --- | Add two vectors element-wise. - -plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -plusFloatX16# = let x = x in x - --- | Add two vectors element-wise. - -plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -plusDoubleX8# = let x = x in x - --- | Subtract two vectors element-wise. - -minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# -minusInt8X16# = let x = x in x - --- | Subtract two vectors element-wise. - -minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# -minusInt16X8# = let x = x in x - --- | Subtract two vectors element-wise. - -minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# -minusInt32X4# = let x = x in x - --- | Subtract two vectors element-wise. - -minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# -minusInt64X2# = let x = x in x - --- | Subtract two vectors element-wise. - -minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# -minusInt8X32# = let x = x in x - --- | Subtract two vectors element-wise. - -minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# -minusInt16X16# = let x = x in x - --- | Subtract two vectors element-wise. - -minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# -minusInt32X8# = let x = x in x - --- | Subtract two vectors element-wise. - -minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# -minusInt64X4# = let x = x in x - --- | Subtract two vectors element-wise. - -minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# -minusInt8X64# = let x = x in x - --- | Subtract two vectors element-wise. - -minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# -minusInt16X32# = let x = x in x - --- | Subtract two vectors element-wise. - -minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# -minusInt32X16# = let x = x in x - --- | Subtract two vectors element-wise. - -minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# -minusInt64X8# = let x = x in x - --- | Subtract two vectors element-wise. - -minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# -minusWord8X16# = let x = x in x - --- | Subtract two vectors element-wise. - -minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# -minusWord16X8# = let x = x in x - --- | Subtract two vectors element-wise. - -minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# -minusWord32X4# = let x = x in x - --- | Subtract two vectors element-wise. - -minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# -minusWord64X2# = let x = x in x - --- | Subtract two vectors element-wise. - -minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# -minusWord8X32# = let x = x in x - --- | Subtract two vectors element-wise. - -minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# -minusWord16X16# = let x = x in x - --- | Subtract two vectors element-wise. - -minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# -minusWord32X8# = let x = x in x - --- | Subtract two vectors element-wise. - -minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# -minusWord64X4# = let x = x in x - --- | Subtract two vectors element-wise. - -minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# -minusWord8X64# = let x = x in x - --- | Subtract two vectors element-wise. - -minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# -minusWord16X32# = let x = x in x - --- | Subtract two vectors element-wise. - -minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# -minusWord32X16# = let x = x in x - --- | Subtract two vectors element-wise. - -minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# -minusWord64X8# = let x = x in x - --- | Subtract two vectors element-wise. - -minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -minusFloatX4# = let x = x in x - --- | Subtract two vectors element-wise. - -minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -minusDoubleX2# = let x = x in x - --- | Subtract two vectors element-wise. - -minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -minusFloatX8# = let x = x in x - --- | Subtract two vectors element-wise. - -minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -minusDoubleX4# = let x = x in x - --- | Subtract two vectors element-wise. - -minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -minusFloatX16# = let x = x in x - --- | Subtract two vectors element-wise. - -minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -minusDoubleX8# = let x = x in x - --- | Multiply two vectors element-wise. - -timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# -timesInt8X16# = let x = x in x - --- | Multiply two vectors element-wise. - -timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# -timesInt16X8# = let x = x in x - --- | Multiply two vectors element-wise. - -timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# -timesInt32X4# = let x = x in x - --- | Multiply two vectors element-wise. - -timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# -timesInt64X2# = let x = x in x - --- | Multiply two vectors element-wise. - -timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# -timesInt8X32# = let x = x in x - --- | Multiply two vectors element-wise. - -timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# -timesInt16X16# = let x = x in x - --- | Multiply two vectors element-wise. - -timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# -timesInt32X8# = let x = x in x - --- | Multiply two vectors element-wise. - -timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# -timesInt64X4# = let x = x in x - --- | Multiply two vectors element-wise. - -timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# -timesInt8X64# = let x = x in x - --- | Multiply two vectors element-wise. - -timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# -timesInt16X32# = let x = x in x - --- | Multiply two vectors element-wise. - -timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# -timesInt32X16# = let x = x in x - --- | Multiply two vectors element-wise. - -timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# -timesInt64X8# = let x = x in x - --- | Multiply two vectors element-wise. - -timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# -timesWord8X16# = let x = x in x - --- | Multiply two vectors element-wise. - -timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# -timesWord16X8# = let x = x in x - --- | Multiply two vectors element-wise. - -timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# -timesWord32X4# = let x = x in x - --- | Multiply two vectors element-wise. - -timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# -timesWord64X2# = let x = x in x - --- | Multiply two vectors element-wise. - -timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# -timesWord8X32# = let x = x in x - --- | Multiply two vectors element-wise. - -timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# -timesWord16X16# = let x = x in x - --- | Multiply two vectors element-wise. - -timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# -timesWord32X8# = let x = x in x - --- | Multiply two vectors element-wise. - -timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# -timesWord64X4# = let x = x in x - --- | Multiply two vectors element-wise. - -timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# -timesWord8X64# = let x = x in x - --- | Multiply two vectors element-wise. - -timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# -timesWord16X32# = let x = x in x - --- | Multiply two vectors element-wise. - -timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# -timesWord32X16# = let x = x in x - --- | Multiply two vectors element-wise. - -timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# -timesWord64X8# = let x = x in x - --- | Multiply two vectors element-wise. - -timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -timesFloatX4# = let x = x in x - --- | Multiply two vectors element-wise. - -timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -timesDoubleX2# = let x = x in x - --- | Multiply two vectors element-wise. - -timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -timesFloatX8# = let x = x in x - --- | Multiply two vectors element-wise. - -timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -timesDoubleX4# = let x = x in x - --- | Multiply two vectors element-wise. - -timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -timesFloatX16# = let x = x in x - --- | Multiply two vectors element-wise. - -timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -timesDoubleX8# = let x = x in x - --- | Divide two vectors element-wise. - -divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -divideFloatX4# = let x = x in x - --- | Divide two vectors element-wise. - -divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -divideDoubleX2# = let x = x in x - --- | Divide two vectors element-wise. - -divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -divideFloatX8# = let x = x in x - --- | Divide two vectors element-wise. - -divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -divideDoubleX4# = let x = x in x - --- | Divide two vectors element-wise. - -divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -divideFloatX16# = let x = x in x - --- | Divide two vectors element-wise. - -divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -divideDoubleX8# = let x = x in x - --- | Rounds towards zero element-wise. - -quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# -quotInt8X16# = let x = x in x - --- | Rounds towards zero element-wise. - -quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# -quotInt16X8# = let x = x in x - --- | Rounds towards zero element-wise. - -quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# -quotInt32X4# = let x = x in x - --- | Rounds towards zero element-wise. - -quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# -quotInt64X2# = let x = x in x - --- | Rounds towards zero element-wise. - -quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# -quotInt8X32# = let x = x in x - --- | Rounds towards zero element-wise. - -quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# -quotInt16X16# = let x = x in x - --- | Rounds towards zero element-wise. - -quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# -quotInt32X8# = let x = x in x - --- | Rounds towards zero element-wise. - -quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# -quotInt64X4# = let x = x in x - --- | Rounds towards zero element-wise. - -quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# -quotInt8X64# = let x = x in x - --- | Rounds towards zero element-wise. - -quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# -quotInt16X32# = let x = x in x - --- | Rounds towards zero element-wise. - -quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# -quotInt32X16# = let x = x in x - --- | Rounds towards zero element-wise. - -quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# -quotInt64X8# = let x = x in x - --- | Rounds towards zero element-wise. - -quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# -quotWord8X16# = let x = x in x - --- | Rounds towards zero element-wise. - -quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# -quotWord16X8# = let x = x in x - --- | Rounds towards zero element-wise. - -quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# -quotWord32X4# = let x = x in x - --- | Rounds towards zero element-wise. - -quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# -quotWord64X2# = let x = x in x - --- | Rounds towards zero element-wise. - -quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# -quotWord8X32# = let x = x in x - --- | Rounds towards zero element-wise. - -quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# -quotWord16X16# = let x = x in x - --- | Rounds towards zero element-wise. - -quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# -quotWord32X8# = let x = x in x - --- | Rounds towards zero element-wise. - -quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# -quotWord64X4# = let x = x in x - --- | Rounds towards zero element-wise. - -quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# -quotWord8X64# = let x = x in x - --- | Rounds towards zero element-wise. - -quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# -quotWord16X32# = let x = x in x - --- | Rounds towards zero element-wise. - -quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# -quotWord32X16# = let x = x in x - --- | Rounds towards zero element-wise. - -quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# -quotWord64X8# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# -remInt8X16# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# -remInt16X8# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# -remInt32X4# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# -remInt64X2# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# -remInt8X32# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# -remInt16X16# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# -remInt32X8# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# -remInt64X4# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# -remInt8X64# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# -remInt16X32# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# -remInt32X16# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# -remInt64X8# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# -remWord8X16# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# -remWord16X8# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# -remWord32X4# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# -remWord64X2# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# -remWord8X32# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# -remWord16X16# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# -remWord32X8# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# -remWord64X4# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# -remWord8X64# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# -remWord16X32# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# -remWord32X16# = let x = x in x - --- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. - -remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# -remWord64X8# = let x = x in x - --- | Negate element-wise. - -negateInt8X16# :: Int8X16# -> Int8X16# -negateInt8X16# = let x = x in x - --- | Negate element-wise. - -negateInt16X8# :: Int16X8# -> Int16X8# -negateInt16X8# = let x = x in x - --- | Negate element-wise. - -negateInt32X4# :: Int32X4# -> Int32X4# -negateInt32X4# = let x = x in x - --- | Negate element-wise. - -negateInt64X2# :: Int64X2# -> Int64X2# -negateInt64X2# = let x = x in x - --- | Negate element-wise. - -negateInt8X32# :: Int8X32# -> Int8X32# -negateInt8X32# = let x = x in x - --- | Negate element-wise. - -negateInt16X16# :: Int16X16# -> Int16X16# -negateInt16X16# = let x = x in x - --- | Negate element-wise. - -negateInt32X8# :: Int32X8# -> Int32X8# -negateInt32X8# = let x = x in x - --- | Negate element-wise. - -negateInt64X4# :: Int64X4# -> Int64X4# -negateInt64X4# = let x = x in x - --- | Negate element-wise. - -negateInt8X64# :: Int8X64# -> Int8X64# -negateInt8X64# = let x = x in x - --- | Negate element-wise. - -negateInt16X32# :: Int16X32# -> Int16X32# -negateInt16X32# = let x = x in x - --- | Negate element-wise. - -negateInt32X16# :: Int32X16# -> Int32X16# -negateInt32X16# = let x = x in x - --- | Negate element-wise. - -negateInt64X8# :: Int64X8# -> Int64X8# -negateInt64X8# = let x = x in x - --- | Negate element-wise. - -negateFloatX4# :: FloatX4# -> FloatX4# -negateFloatX4# = let x = x in x - --- | Negate element-wise. - -negateDoubleX2# :: DoubleX2# -> DoubleX2# -negateDoubleX2# = let x = x in x - --- | Negate element-wise. - -negateFloatX8# :: FloatX8# -> FloatX8# -negateFloatX8# = let x = x in x - --- | Negate element-wise. - -negateDoubleX4# :: DoubleX4# -> DoubleX4# -negateDoubleX4# = let x = x in x - --- | Negate element-wise. - -negateFloatX16# :: FloatX16# -> FloatX16# -negateFloatX16# = let x = x in x - --- | Negate element-wise. - -negateDoubleX8# :: DoubleX8# -> DoubleX8# -negateDoubleX8# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16# -indexInt8X16Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8# -indexInt16X8Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4# -indexInt32X4Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2# -indexInt64X2Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32# -indexInt8X32Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16# -indexInt16X16Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8# -indexInt32X8Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4# -indexInt64X4Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64# -indexInt8X64Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32# -indexInt16X32Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16# -indexInt32X16Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8# -indexInt64X8Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16# -indexWord8X16Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8# -indexWord16X8Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4# -indexWord32X4Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2# -indexWord64X2Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32# -indexWord8X32Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16# -indexWord16X16Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8# -indexWord32X8Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4# -indexWord64X4Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64# -indexWord8X64Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32# -indexWord16X32Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16# -indexWord32X16Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8# -indexWord64X8Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4# -indexFloatX4Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2# -indexDoubleX2Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8# -indexFloatX8Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4# -indexDoubleX4Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16# -indexFloatX16Array# = let x = x in x - --- | Read a vector from specified index of immutable array. - -indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8# -indexDoubleX8Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readInt8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #) -readInt8X16Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readInt16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #) -readInt16X8Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readInt32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #) -readInt32X4Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readInt64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #) -readInt64X2Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readInt8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #) -readInt8X32Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readInt16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #) -readInt16X16Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readInt32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #) -readInt32X8Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readInt64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #) -readInt64X4Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readInt8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #) -readInt8X64Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readInt16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #) -readInt16X32Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readInt32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #) -readInt32X16Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readInt64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #) -readInt64X8Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readWord8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #) -readWord8X16Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readWord16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #) -readWord16X8Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readWord32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #) -readWord32X4Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readWord64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #) -readWord64X2Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readWord8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #) -readWord8X32Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readWord16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #) -readWord16X16Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readWord32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #) -readWord32X8Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readWord64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #) -readWord64X4Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readWord8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #) -readWord8X64Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readWord16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #) -readWord16X32Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readWord32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #) -readWord32X16Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readWord64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #) -readWord64X8Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readFloatX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #) -readFloatX4Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readDoubleX2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #) -readDoubleX2Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readFloatX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #) -readFloatX8Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readDoubleX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #) -readDoubleX4Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readFloatX16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #) -readFloatX16Array# = let x = x in x - --- | Read a vector from specified index of mutable array. - -readDoubleX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #) -readDoubleX8Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeInt8X16Array# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s -writeInt8X16Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeInt16X8Array# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s -writeInt16X8Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeInt32X4Array# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s -writeInt32X4Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeInt64X2Array# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s -writeInt64X2Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeInt8X32Array# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s -writeInt8X32Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeInt16X16Array# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s -writeInt16X16Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeInt32X8Array# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s -writeInt32X8Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeInt64X4Array# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s -writeInt64X4Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeInt8X64Array# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s -writeInt8X64Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeInt16X32Array# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s -writeInt16X32Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeInt32X16Array# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s -writeInt32X16Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeInt64X8Array# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s -writeInt64X8Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeWord8X16Array# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s -writeWord8X16Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeWord16X8Array# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s -writeWord16X8Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeWord32X4Array# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s -writeWord32X4Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeWord64X2Array# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s -writeWord64X2Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeWord8X32Array# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s -writeWord8X32Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeWord16X16Array# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s -writeWord16X16Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeWord32X8Array# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s -writeWord32X8Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeWord64X4Array# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s -writeWord64X4Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeWord8X64Array# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s -writeWord8X64Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeWord16X32Array# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s -writeWord16X32Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeWord32X16Array# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s -writeWord32X16Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeWord64X8Array# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s -writeWord64X8Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeFloatX4Array# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s -writeFloatX4Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeDoubleX2Array# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s -writeDoubleX2Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeFloatX8Array# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s -writeFloatX8Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeDoubleX4Array# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s -writeDoubleX4Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeFloatX16Array# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s -writeFloatX16Array# = let x = x in x - --- | Write a vector to specified index of mutable array. - -writeDoubleX8Array# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s -writeDoubleX8Array# = let x = x in x - --- | Reads vector; offset in bytes. - -indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -indexInt8X16OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -indexInt16X8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -indexInt32X4OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -indexInt64X2OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -indexInt8X32OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -indexInt16X16OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -indexInt32X8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -indexInt64X4OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -indexInt8X64OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -indexInt16X32OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -indexInt32X16OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -indexInt64X8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -indexWord8X16OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -indexWord16X8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -indexWord32X4OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -indexWord64X2OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -indexWord8X32OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -indexWord16X16OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -indexWord32X8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -indexWord64X4OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -indexWord8X64OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -indexWord16X32OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -indexWord32X16OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -indexWord64X8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -indexFloatX4OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -indexDoubleX2OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -indexFloatX8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -indexDoubleX4OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -indexFloatX16OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -indexDoubleX8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readInt8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #) -readInt8X16OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readInt16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #) -readInt16X8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readInt32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #) -readInt32X4OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readInt64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #) -readInt64X2OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readInt8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #) -readInt8X32OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readInt16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #) -readInt16X16OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readInt32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #) -readInt32X8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readInt64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #) -readInt64X4OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readInt8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #) -readInt8X64OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readInt16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #) -readInt16X32OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readInt32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #) -readInt32X16OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readInt64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #) -readInt64X8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readWord8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #) -readWord8X16OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readWord16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #) -readWord16X8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readWord32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #) -readWord32X4OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readWord64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #) -readWord64X2OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readWord8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #) -readWord8X32OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readWord16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #) -readWord16X16OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readWord32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #) -readWord32X8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readWord64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #) -readWord64X4OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readWord8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #) -readWord8X64OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readWord16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #) -readWord16X32OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readWord32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #) -readWord32X16OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readWord64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #) -readWord64X8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readFloatX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #) -readFloatX4OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readDoubleX2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #) -readDoubleX2OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readFloatX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #) -readFloatX8OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readDoubleX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #) -readDoubleX4OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readFloatX16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #) -readFloatX16OffAddr# = let x = x in x - --- | Reads vector; offset in bytes. - -readDoubleX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #) -readDoubleX8OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s -writeInt8X16OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s -writeInt16X8OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s -writeInt32X4OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s -writeInt64X2OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s -writeInt8X32OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s -writeInt16X16OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s -writeInt32X8OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s -writeInt64X4OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s -writeInt8X64OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s -writeInt16X32OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s -writeInt32X16OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s -writeInt64X8OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s -writeWord8X16OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s -writeWord16X8OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s -writeWord32X4OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s -writeWord64X2OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s -writeWord8X32OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s -writeWord16X16OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s -writeWord32X8OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s -writeWord64X4OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s -writeWord8X64OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s -writeWord16X32OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s -writeWord32X16OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s -writeWord64X8OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s -writeFloatX4OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s -writeDoubleX2OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s -writeFloatX8OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s -writeDoubleX4OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s -writeFloatX16OffAddr# = let x = x in x - --- | Write vector; offset in bytes. - -writeDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s -writeDoubleX8OffAddr# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16# -indexInt8ArrayAsInt8X16# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8# -indexInt16ArrayAsInt16X8# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4# -indexInt32ArrayAsInt32X4# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2# -indexInt64ArrayAsInt64X2# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32# -indexInt8ArrayAsInt8X32# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16# -indexInt16ArrayAsInt16X16# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8# -indexInt32ArrayAsInt32X8# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4# -indexInt64ArrayAsInt64X4# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64# -indexInt8ArrayAsInt8X64# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32# -indexInt16ArrayAsInt16X32# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16# -indexInt32ArrayAsInt32X16# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8# -indexInt64ArrayAsInt64X8# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16# -indexWord8ArrayAsWord8X16# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8# -indexWord16ArrayAsWord16X8# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4# -indexWord32ArrayAsWord32X4# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2# -indexWord64ArrayAsWord64X2# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32# -indexWord8ArrayAsWord8X32# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16# -indexWord16ArrayAsWord16X16# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8# -indexWord32ArrayAsWord32X8# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4# -indexWord64ArrayAsWord64X4# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64# -indexWord8ArrayAsWord8X64# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32# -indexWord16ArrayAsWord16X32# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16# -indexWord32ArrayAsWord32X16# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8# -indexWord64ArrayAsWord64X8# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4# -indexFloatArrayAsFloatX4# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2# -indexDoubleArrayAsDoubleX2# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8# -indexFloatArrayAsFloatX8# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4# -indexDoubleArrayAsDoubleX4# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16# -indexFloatArrayAsFloatX16# = let x = x in x - --- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. - -indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8# -indexDoubleArrayAsDoubleX8# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #) -readInt8ArrayAsInt8X16# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #) -readInt16ArrayAsInt16X8# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #) -readInt32ArrayAsInt32X4# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #) -readInt64ArrayAsInt64X2# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #) -readInt8ArrayAsInt8X32# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #) -readInt16ArrayAsInt16X16# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #) -readInt32ArrayAsInt32X8# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #) -readInt64ArrayAsInt64X4# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #) -readInt8ArrayAsInt8X64# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #) -readInt16ArrayAsInt16X32# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #) -readInt32ArrayAsInt32X16# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #) -readInt64ArrayAsInt64X8# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #) -readWord8ArrayAsWord8X16# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #) -readWord16ArrayAsWord16X8# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #) -readWord32ArrayAsWord32X4# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #) -readWord64ArrayAsWord64X2# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #) -readWord8ArrayAsWord8X32# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #) -readWord16ArrayAsWord16X16# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #) -readWord32ArrayAsWord32X8# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #) -readWord64ArrayAsWord64X4# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #) -readWord8ArrayAsWord8X64# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #) -readWord16ArrayAsWord16X32# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #) -readWord32ArrayAsWord32X16# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #) -readWord64ArrayAsWord64X8# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #) -readFloatArrayAsFloatX4# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #) -readDoubleArrayAsDoubleX2# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #) -readFloatArrayAsFloatX8# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #) -readDoubleArrayAsDoubleX4# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #) -readFloatArrayAsFloatX16# = let x = x in x - --- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. - -readDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #) -readDoubleArrayAsDoubleX8# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s -writeInt8ArrayAsInt8X16# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s -writeInt16ArrayAsInt16X8# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s -writeInt32ArrayAsInt32X4# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s -writeInt64ArrayAsInt64X2# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s -writeInt8ArrayAsInt8X32# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s -writeInt16ArrayAsInt16X16# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s -writeInt32ArrayAsInt32X8# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s -writeInt64ArrayAsInt64X4# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s -writeInt8ArrayAsInt8X64# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s -writeInt16ArrayAsInt16X32# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s -writeInt32ArrayAsInt32X16# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s -writeInt64ArrayAsInt64X8# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s -writeWord8ArrayAsWord8X16# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s -writeWord16ArrayAsWord16X8# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s -writeWord32ArrayAsWord32X4# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s -writeWord64ArrayAsWord64X2# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s -writeWord8ArrayAsWord8X32# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s -writeWord16ArrayAsWord16X16# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s -writeWord32ArrayAsWord32X8# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s -writeWord64ArrayAsWord64X4# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s -writeWord8ArrayAsWord8X64# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s -writeWord16ArrayAsWord16X32# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s -writeWord32ArrayAsWord32X16# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s -writeWord64ArrayAsWord64X8# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s -writeFloatArrayAsFloatX4# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s -writeDoubleArrayAsDoubleX2# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s -writeFloatArrayAsFloatX8# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s -writeDoubleArrayAsDoubleX4# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s -writeFloatArrayAsFloatX16# = let x = x in x - --- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. - -writeDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s -writeDoubleArrayAsDoubleX8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -indexInt8OffAddrAsInt8X16# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -indexInt16OffAddrAsInt16X8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -indexInt32OffAddrAsInt32X4# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -indexInt64OffAddrAsInt64X2# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -indexInt8OffAddrAsInt8X32# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -indexInt16OffAddrAsInt16X16# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -indexInt32OffAddrAsInt32X8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -indexInt64OffAddrAsInt64X4# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -indexInt8OffAddrAsInt8X64# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -indexInt16OffAddrAsInt16X32# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -indexInt32OffAddrAsInt32X16# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -indexInt64OffAddrAsInt64X8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -indexWord8OffAddrAsWord8X16# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -indexWord16OffAddrAsWord16X8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -indexWord32OffAddrAsWord32X4# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -indexWord64OffAddrAsWord64X2# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -indexWord8OffAddrAsWord8X32# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -indexWord16OffAddrAsWord16X16# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -indexWord32OffAddrAsWord32X8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -indexWord64OffAddrAsWord64X4# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -indexWord8OffAddrAsWord8X64# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -indexWord16OffAddrAsWord16X32# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -indexWord32OffAddrAsWord32X16# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -indexWord64OffAddrAsWord64X8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -indexFloatOffAddrAsFloatX4# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -indexDoubleOffAddrAsDoubleX2# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -indexFloatOffAddrAsFloatX8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -indexDoubleOffAddrAsDoubleX4# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -indexFloatOffAddrAsFloatX16# = let x = x in x - --- | Reads vector; offset in scalar elements. - -indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -indexDoubleOffAddrAsDoubleX8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readInt8OffAddrAsInt8X16# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #) -readInt8OffAddrAsInt8X16# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readInt16OffAddrAsInt16X8# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #) -readInt16OffAddrAsInt16X8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #) -readInt32OffAddrAsInt32X4# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #) -readInt64OffAddrAsInt64X2# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readInt8OffAddrAsInt8X32# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #) -readInt8OffAddrAsInt8X32# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readInt16OffAddrAsInt16X16# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #) -readInt16OffAddrAsInt16X16# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readInt32OffAddrAsInt32X8# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #) -readInt32OffAddrAsInt32X8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readInt64OffAddrAsInt64X4# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #) -readInt64OffAddrAsInt64X4# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readInt8OffAddrAsInt8X64# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #) -readInt8OffAddrAsInt8X64# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readInt16OffAddrAsInt16X32# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #) -readInt16OffAddrAsInt16X32# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readInt32OffAddrAsInt32X16# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #) -readInt32OffAddrAsInt32X16# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readInt64OffAddrAsInt64X8# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #) -readInt64OffAddrAsInt64X8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readWord8OffAddrAsWord8X16# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #) -readWord8OffAddrAsWord8X16# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readWord16OffAddrAsWord16X8# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #) -readWord16OffAddrAsWord16X8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readWord32OffAddrAsWord32X4# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #) -readWord32OffAddrAsWord32X4# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readWord64OffAddrAsWord64X2# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #) -readWord64OffAddrAsWord64X2# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readWord8OffAddrAsWord8X32# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #) -readWord8OffAddrAsWord8X32# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readWord16OffAddrAsWord16X16# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #) -readWord16OffAddrAsWord16X16# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readWord32OffAddrAsWord32X8# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #) -readWord32OffAddrAsWord32X8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readWord64OffAddrAsWord64X4# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #) -readWord64OffAddrAsWord64X4# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readWord8OffAddrAsWord8X64# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #) -readWord8OffAddrAsWord8X64# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readWord16OffAddrAsWord16X32# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #) -readWord16OffAddrAsWord16X32# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readWord32OffAddrAsWord32X16# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #) -readWord32OffAddrAsWord32X16# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readWord64OffAddrAsWord64X8# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #) -readWord64OffAddrAsWord64X8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #) -readFloatOffAddrAsFloatX4# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #) -readDoubleOffAddrAsDoubleX2# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readFloatOffAddrAsFloatX8# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #) -readFloatOffAddrAsFloatX8# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #) -readDoubleOffAddrAsDoubleX4# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readFloatOffAddrAsFloatX16# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #) -readFloatOffAddrAsFloatX16# = let x = x in x - --- | Reads vector; offset in scalar elements. - -readDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #) -readDoubleOffAddrAsDoubleX8# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s -writeInt8OffAddrAsInt8X16# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s -writeInt16OffAddrAsInt16X8# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s -writeInt32OffAddrAsInt32X4# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s -writeInt64OffAddrAsInt64X2# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s -writeInt8OffAddrAsInt8X32# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s -writeInt16OffAddrAsInt16X16# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s -writeInt32OffAddrAsInt32X8# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s -writeInt64OffAddrAsInt64X4# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s -writeInt8OffAddrAsInt8X64# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s -writeInt16OffAddrAsInt16X32# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s -writeInt32OffAddrAsInt32X16# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s -writeInt64OffAddrAsInt64X8# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s -writeWord8OffAddrAsWord8X16# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s -writeWord16OffAddrAsWord16X8# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s -writeWord32OffAddrAsWord32X4# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s -writeWord64OffAddrAsWord64X2# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s -writeWord8OffAddrAsWord8X32# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s -writeWord16OffAddrAsWord16X16# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s -writeWord32OffAddrAsWord32X8# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s -writeWord64OffAddrAsWord64X4# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s -writeWord8OffAddrAsWord8X64# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s -writeWord16OffAddrAsWord16X32# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s -writeWord32OffAddrAsWord32X16# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s -writeWord64OffAddrAsWord64X8# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s -writeFloatOffAddrAsFloatX4# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s -writeDoubleOffAddrAsDoubleX2# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s -writeFloatOffAddrAsFloatX8# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s -writeDoubleOffAddrAsDoubleX4# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s -writeFloatOffAddrAsFloatX16# = let x = x in x - --- | Write vector; offset in scalar elements. - -writeDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s -writeDoubleOffAddrAsDoubleX8# = let x = x in x - -prefetchByteArray3# :: ByteArray# -> Int# -> State# s -> State# s -prefetchByteArray3# = let x = x in x - -prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s -prefetchMutableByteArray3# = let x = x in x - -prefetchAddr3# :: Addr# -> Int# -> State# s -> State# s -prefetchAddr3# = let x = x in x - -prefetchValue3# :: a -> State# s -> State# s -prefetchValue3# = let x = x in x - -prefetchByteArray2# :: ByteArray# -> Int# -> State# s -> State# s -prefetchByteArray2# = let x = x in x - -prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s -prefetchMutableByteArray2# = let x = x in x - -prefetchAddr2# :: Addr# -> Int# -> State# s -> State# s -prefetchAddr2# = let x = x in x - -prefetchValue2# :: a -> State# s -> State# s -prefetchValue2# = let x = x in x - -prefetchByteArray1# :: ByteArray# -> Int# -> State# s -> State# s -prefetchByteArray1# = let x = x in x - -prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s -prefetchMutableByteArray1# = let x = x in x - -prefetchAddr1# :: Addr# -> Int# -> State# s -> State# s -prefetchAddr1# = let x = x in x - -prefetchValue1# :: a -> State# s -> State# s -prefetchValue1# = let x = x in x - -prefetchByteArray0# :: ByteArray# -> Int# -> State# s -> State# s -prefetchByteArray0# = let x = x in x - -prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s -prefetchMutableByteArray0# = let x = x in x - -prefetchAddr0# :: Addr# -> Int# -> State# s -> State# s -prefetchAddr0# = let x = x in x - -prefetchValue0# :: a -> State# s -> State# s -prefetchValue0# = let x = x in x +{-# OPTIONS_GHC -fno-warn-redundant-constraints #-} +module GHC.Prim ( + +-- * The word size story. +-- |Haskell98 specifies that signed integers (type @Int@) +-- must contain at least 30 bits. GHC always implements @Int@ using the primitive type @Int\#@, whose size equals +-- the @MachDeps.h@ constant @WORD\_SIZE\_IN\_BITS@. +-- This is normally set based on the @config.h@ parameter +-- @SIZEOF\_HSWORD@, i.e., 32 bits on 32-bit machines, 64 +-- bits on 64-bit machines. However, it can also be explicitly +-- set to a smaller number, e.g., 31 bits, to allow the +-- possibility of using tag bits. Currently GHC itself has only +-- 32-bit and 64-bit variants, but 30 or 31-bit code can be +-- exported as an external core file for use in other back ends. +-- +-- GHC also implements a primitive unsigned integer type @Word\#@ which always has the same number of bits as @Int\#@. +-- +-- In addition, GHC supports families of explicit-sized integers +-- and words at 8, 16, 32, and 64 bits, with the usual +-- arithmetic operations, comparisons, and a range of +-- conversions. The 8-bit and 16-bit sizes are always +-- represented as @Int\#@ and @Word\#@, and the +-- operations implemented in terms of the the primops on these +-- types, with suitable range restrictions on the results (using +-- the @narrow$n$Int\#@ and @narrow$n$Word\#@ families +-- of primops. The 32-bit sizes are represented using @Int\#@ and @Word\#@ when @WORD\_SIZE\_IN\_BITS@ +-- $\geq$ 32; otherwise, these are represented using distinct +-- primitive types @Int32\#@ and @Word32\#@. These (when +-- needed) have a complete set of corresponding operations; +-- however, nearly all of these are implemented as external C +-- functions rather than as primops. Exactly the same story +-- applies to the 64-bit sizes. All of these details are hidden +-- under the @PrelInt@ and @PrelWord@ modules, which use +-- @\#if@-defs to invoke the appropriate types and +-- operators. +-- +-- Word size also matters for the families of primops for +-- indexing\/reading\/writing fixed-size quantities at offsets +-- from an array base, address, or foreign pointer. Here, a +-- slightly different approach is taken. The names of these +-- primops are fixed, but their /types/ vary according to +-- the value of @WORD\_SIZE\_IN\_BITS@. For example, if word +-- size is at least 32 bits then an operator like +-- @indexInt32Array\#@ has type @ByteArray\# -> Int\# -> Int\#@; otherwise it has type @ByteArray\# -> Int\# -> Int32\#@. This approach confines the necessary @\#if@-defs to this file; no conditional compilation is needed +-- in the files that expose these primops. +-- +-- Finally, there are strongly deprecated primops for coercing +-- between @Addr\#@, the primitive type of machine +-- addresses, and @Int\#@. These are pretty bogus anyway, +-- but will work on existing 32-bit and 64-bit GHC targets; they +-- are completely bogus when tag bits are used in @Int\#@, +-- so are not available in this case. + + + +-- * Char# +-- |Operations on 31-bit characters. + + + Char#, + gtChar#, + geChar#, + eqChar#, + neChar#, + ltChar#, + leChar#, + ord#, + +-- * Int# +-- |Operations on native-size integers (30+ bits). + + + Int#, + (+#), + (-#), + (*#), + mulIntMayOflo#, + quotInt#, + remInt#, + quotRemInt#, + andI#, + orI#, + xorI#, + notI#, + negateInt#, + addIntC#, + subIntC#, + (>#), + (>=#), + (==#), + (/=#), + (<#), + (<=#), + chr#, + int2Word#, + int2Float#, + int2Double#, + word2Float#, + word2Double#, + uncheckedIShiftL#, + uncheckedIShiftRA#, + uncheckedIShiftRL#, + +-- * Word# +-- |Operations on native-sized unsigned words (30+ bits). + + + Word#, + plusWord#, + subWordC#, + plusWord2#, + minusWord#, + timesWord#, + timesWord2#, + quotWord#, + remWord#, + quotRemWord#, + quotRemWord2#, + and#, + or#, + xor#, + not#, + uncheckedShiftL#, + uncheckedShiftRL#, + word2Int#, + gtWord#, + geWord#, + eqWord#, + neWord#, + ltWord#, + leWord#, + popCnt8#, + popCnt16#, + popCnt32#, + popCnt64#, + popCnt#, + clz8#, + clz16#, + clz32#, + clz64#, + clz#, + ctz8#, + ctz16#, + ctz32#, + ctz64#, + ctz#, + byteSwap16#, + byteSwap32#, + byteSwap64#, + byteSwap#, + +-- * Narrowings +-- |Explicit narrowing of native-sized ints or words. + + + narrow8Int#, + narrow16Int#, + narrow32Int#, + narrow8Word#, + narrow16Word#, + narrow32Word#, + +-- * Double# +-- |Operations on double-precision (64 bit) floating-point numbers. + + + Double#, + (>##), + (>=##), + (==##), + (/=##), + (<##), + (<=##), + (+##), + (-##), + (*##), + (/##), + negateDouble#, + double2Int#, + double2Float#, + expDouble#, + logDouble#, + sqrtDouble#, + sinDouble#, + cosDouble#, + tanDouble#, + asinDouble#, + acosDouble#, + atanDouble#, + sinhDouble#, + coshDouble#, + tanhDouble#, + (**##), + decodeDouble_2Int#, + decodeDouble_Int64#, + +-- * Float# +-- |Operations on single-precision (32-bit) floating-point numbers. + + + Float#, + gtFloat#, + geFloat#, + eqFloat#, + neFloat#, + ltFloat#, + leFloat#, + plusFloat#, + minusFloat#, + timesFloat#, + divideFloat#, + negateFloat#, + float2Int#, + expFloat#, + logFloat#, + sqrtFloat#, + sinFloat#, + cosFloat#, + tanFloat#, + asinFloat#, + acosFloat#, + atanFloat#, + sinhFloat#, + coshFloat#, + tanhFloat#, + powerFloat#, + float2Double#, + decodeFloat_Int#, + +-- * Arrays +-- |Operations on @Array\#@. + + + Array#, + MutableArray#, + newArray#, + sameMutableArray#, + readArray#, + writeArray#, + sizeofArray#, + sizeofMutableArray#, + indexArray#, + unsafeFreezeArray#, + unsafeThawArray#, + copyArray#, + copyMutableArray#, + cloneArray#, + cloneMutableArray#, + freezeArray#, + thawArray#, + casArray#, + +-- * Small Arrays +-- |Operations on @SmallArray\#@. A @SmallArray\#@ works +-- just like an @Array\#@, but with different space use and +-- performance characteristics (that are often useful with small +-- arrays). The @SmallArray\#@ and @SmallMutableArray#@ +-- lack a \`card table\'. The purpose of a card table is to avoid +-- having to scan every element of the array on each GC by +-- keeping track of which elements have changed since the last GC +-- and only scanning those that have changed. So the consequence +-- of there being no card table is that the representation is +-- somewhat smaller and the writes are somewhat faster (because +-- the card table does not need to be updated). The disadvantage +-- of course is that for a @SmallMutableArray#@ the whole +-- array has to be scanned on each GC. Thus it is best suited for +-- use cases where the mutable array is not long lived, e.g. +-- where a mutable array is initialised quickly and then frozen +-- to become an immutable @SmallArray\#@. +-- + + + SmallArray#, + SmallMutableArray#, + newSmallArray#, + sameSmallMutableArray#, + readSmallArray#, + writeSmallArray#, + sizeofSmallArray#, + sizeofSmallMutableArray#, + indexSmallArray#, + unsafeFreezeSmallArray#, + unsafeThawSmallArray#, + copySmallArray#, + copySmallMutableArray#, + cloneSmallArray#, + cloneSmallMutableArray#, + freezeSmallArray#, + thawSmallArray#, + casSmallArray#, + +-- * Byte Arrays +-- |Operations on @ByteArray\#@. A @ByteArray\#@ is a just a region of +-- raw memory in the garbage-collected heap, which is not +-- scanned for pointers. It carries its own size (in bytes). +-- There are +-- three sets of operations for accessing byte array contents: +-- index for reading from immutable byte arrays, and read\/write +-- for mutable byte arrays. Each set contains operations for a +-- range of useful primitive data types. Each operation takes +-- an offset measured in terms of the size of the primitive type +-- being read or written. + + + ByteArray#, + MutableByteArray#, + newByteArray#, + newPinnedByteArray#, + newAlignedPinnedByteArray#, + byteArrayContents#, + sameMutableByteArray#, + shrinkMutableByteArray#, + resizeMutableByteArray#, + unsafeFreezeByteArray#, + sizeofByteArray#, + sizeofMutableByteArray#, + getSizeofMutableByteArray#, + indexCharArray#, + indexWideCharArray#, + indexIntArray#, + indexWordArray#, + indexAddrArray#, + indexFloatArray#, + indexDoubleArray#, + indexStablePtrArray#, + indexInt8Array#, + indexInt16Array#, + indexInt32Array#, + indexInt64Array#, + indexWord8Array#, + indexWord16Array#, + indexWord32Array#, + indexWord64Array#, + readCharArray#, + readWideCharArray#, + readIntArray#, + readWordArray#, + readAddrArray#, + readFloatArray#, + readDoubleArray#, + readStablePtrArray#, + readInt8Array#, + readInt16Array#, + readInt32Array#, + readInt64Array#, + readWord8Array#, + readWord16Array#, + readWord32Array#, + readWord64Array#, + writeCharArray#, + writeWideCharArray#, + writeIntArray#, + writeWordArray#, + writeAddrArray#, + writeFloatArray#, + writeDoubleArray#, + writeStablePtrArray#, + writeInt8Array#, + writeInt16Array#, + writeInt32Array#, + writeInt64Array#, + writeWord8Array#, + writeWord16Array#, + writeWord32Array#, + writeWord64Array#, + copyByteArray#, + copyMutableByteArray#, + copyByteArrayToAddr#, + copyMutableByteArrayToAddr#, + copyAddrToByteArray#, + setByteArray#, + atomicReadIntArray#, + atomicWriteIntArray#, + casIntArray#, + fetchAddIntArray#, + fetchSubIntArray#, + fetchAndIntArray#, + fetchNandIntArray#, + fetchOrIntArray#, + fetchXorIntArray#, + +-- * Arrays of arrays +-- |Operations on @ArrayArray\#@. An @ArrayArray\#@ contains references to {\em unpointed} +-- arrays, such as @ByteArray\#s@. Hence, it is not parameterised by the element types, +-- just like a @ByteArray\#@, but it needs to be scanned during GC, just like an @Array#@. +-- We represent an @ArrayArray\#@ exactly as a @Array\#@, but provide element-type-specific +-- indexing, reading, and writing. + + + ArrayArray#, + MutableArrayArray#, + newArrayArray#, + sameMutableArrayArray#, + unsafeFreezeArrayArray#, + sizeofArrayArray#, + sizeofMutableArrayArray#, + indexByteArrayArray#, + indexArrayArrayArray#, + readByteArrayArray#, + readMutableByteArrayArray#, + readArrayArrayArray#, + readMutableArrayArrayArray#, + writeByteArrayArray#, + writeMutableByteArrayArray#, + writeArrayArrayArray#, + writeMutableArrayArrayArray#, + copyArrayArray#, + copyMutableArrayArray#, + +-- * Addr# +-- | + + + Addr#, + nullAddr#, + plusAddr#, + minusAddr#, + remAddr#, + addr2Int#, + int2Addr#, + gtAddr#, + geAddr#, + eqAddr#, + neAddr#, + ltAddr#, + leAddr#, + indexCharOffAddr#, + indexWideCharOffAddr#, + indexIntOffAddr#, + indexWordOffAddr#, + indexAddrOffAddr#, + indexFloatOffAddr#, + indexDoubleOffAddr#, + indexStablePtrOffAddr#, + indexInt8OffAddr#, + indexInt16OffAddr#, + indexInt32OffAddr#, + indexInt64OffAddr#, + indexWord8OffAddr#, + indexWord16OffAddr#, + indexWord32OffAddr#, + indexWord64OffAddr#, + readCharOffAddr#, + readWideCharOffAddr#, + readIntOffAddr#, + readWordOffAddr#, + readAddrOffAddr#, + readFloatOffAddr#, + readDoubleOffAddr#, + readStablePtrOffAddr#, + readInt8OffAddr#, + readInt16OffAddr#, + readInt32OffAddr#, + readInt64OffAddr#, + readWord8OffAddr#, + readWord16OffAddr#, + readWord32OffAddr#, + readWord64OffAddr#, + writeCharOffAddr#, + writeWideCharOffAddr#, + writeIntOffAddr#, + writeWordOffAddr#, + writeAddrOffAddr#, + writeFloatOffAddr#, + writeDoubleOffAddr#, + writeStablePtrOffAddr#, + writeInt8OffAddr#, + writeInt16OffAddr#, + writeInt32OffAddr#, + writeInt64OffAddr#, + writeWord8OffAddr#, + writeWord16OffAddr#, + writeWord32OffAddr#, + writeWord64OffAddr#, + +-- * Mutable variables +-- |Operations on MutVar\#s. + + + MutVar#, + newMutVar#, + readMutVar#, + writeMutVar#, + sameMutVar#, + atomicModifyMutVar#, + casMutVar#, + +-- * Exceptions +-- |- Note [Strictness for mask\/unmask\/catch] +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- Consider this example, which comes from GHC.IO.Handle.Internals: +-- wantReadableHandle3 f ma b st +-- = case ... of +-- DEFAULT -> case ma of MVar a -> ... +-- 0# -> maskAsynchExceptions# (\st -> case ma of MVar a -> ...) +-- The outer case just decides whether to mask exceptions, but we don\'t want +-- thereby to hide the strictness in \'ma\'! Hence the use of strictApply1Dmd. +-- +-- For catch, we must be extra careful; see +-- Note [Exceptions and strictness] in Demand +-- - + + + catch#, + raise#, + raiseIO#, + maskAsyncExceptions#, + maskUninterruptible#, + unmaskAsyncExceptions#, + getMaskingState#, + +-- * STM-accessible Mutable Variables +-- | + + + TVar#, + atomically#, + retry#, + catchRetry#, + catchSTM#, + check#, + newTVar#, + readTVar#, + readTVarIO#, + writeTVar#, + sameTVar#, + +-- * Synchronized Mutable Variables +-- |Operations on @MVar\#@s. + + + MVar#, + newMVar#, + takeMVar#, + tryTakeMVar#, + putMVar#, + tryPutMVar#, + readMVar#, + tryReadMVar#, + sameMVar#, + isEmptyMVar#, + +-- * Delay\/wait operations +-- | + + + delay#, + waitRead#, + waitWrite#, + +-- * Concurrency primitives +-- | + + + State#, + RealWorld, + ThreadId#, + fork#, + forkOn#, + killThread#, + yield#, + myThreadId#, + labelThread#, + isCurrentThreadBound#, + noDuplicate#, + threadStatus#, + +-- * Weak pointers +-- | + + + Weak#, + mkWeak#, + mkWeakNoFinalizer#, + addCFinalizerToWeak#, + deRefWeak#, + finalizeWeak#, + touch#, + +-- * Stable pointers and names +-- | + + + StablePtr#, + StableName#, + makeStablePtr#, + deRefStablePtr#, + eqStablePtr#, + makeStableName#, + eqStableName#, + stableNameToInt#, + +-- * Unsafe pointer equality +-- | + + + reallyUnsafePtrEquality#, + +-- * Parallelism +-- | + + + par#, + spark#, + seq#, + getSpark#, + numSparks#, + +-- * Tag to enum stuff +-- |Convert back and forth between values of enumerated types +-- and small integers. + + + dataToTag#, + tagToEnum#, + +-- * Bytecode operations +-- |Support for manipulating bytecode objects used by the interpreter and +-- linker. +-- +-- Bytecode objects are heap objects which represent top-level bindings and +-- contain a list of instructions and data needed by these instructions. + + + BCO#, + addrToAny#, + mkApUpd0#, + newBCO#, + unpackClosure#, + getApStackVal#, + +-- * Misc +-- |These aren\'t nearly as wired in as Etc... + + + getCCSOf#, + getCurrentCCS#, + clearCCS#, + +-- * Etc +-- |Miscellaneous built-ins + + + Proxy#, + proxy#, + seq, + Any, + AnyK, + unsafeCoerce#, + traceEvent#, + traceMarker#, + +-- * Safe coercions +-- | + + + coerce, + +-- * SIMD Vectors +-- |Operations on SIMD vectors. + + + Int8X16#, + Int16X8#, + Int32X4#, + Int64X2#, + Int8X32#, + Int16X16#, + Int32X8#, + Int64X4#, + Int8X64#, + Int16X32#, + Int32X16#, + Int64X8#, + Word8X16#, + Word16X8#, + Word32X4#, + Word64X2#, + Word8X32#, + Word16X16#, + Word32X8#, + Word64X4#, + Word8X64#, + Word16X32#, + Word32X16#, + Word64X8#, + FloatX4#, + DoubleX2#, + FloatX8#, + DoubleX4#, + FloatX16#, + DoubleX8#, + broadcastInt8X16#, + broadcastInt16X8#, + broadcastInt32X4#, + broadcastInt64X2#, + broadcastInt8X32#, + broadcastInt16X16#, + broadcastInt32X8#, + broadcastInt64X4#, + broadcastInt8X64#, + broadcastInt16X32#, + broadcastInt32X16#, + broadcastInt64X8#, + broadcastWord8X16#, + broadcastWord16X8#, + broadcastWord32X4#, + broadcastWord64X2#, + broadcastWord8X32#, + broadcastWord16X16#, + broadcastWord32X8#, + broadcastWord64X4#, + broadcastWord8X64#, + broadcastWord16X32#, + broadcastWord32X16#, + broadcastWord64X8#, + broadcastFloatX4#, + broadcastDoubleX2#, + broadcastFloatX8#, + broadcastDoubleX4#, + broadcastFloatX16#, + broadcastDoubleX8#, + packInt8X16#, + packInt16X8#, + packInt32X4#, + packInt64X2#, + packInt8X32#, + packInt16X16#, + packInt32X8#, + packInt64X4#, + packInt8X64#, + packInt16X32#, + packInt32X16#, + packInt64X8#, + packWord8X16#, + packWord16X8#, + packWord32X4#, + packWord64X2#, + packWord8X32#, + packWord16X16#, + packWord32X8#, + packWord64X4#, + packWord8X64#, + packWord16X32#, + packWord32X16#, + packWord64X8#, + packFloatX4#, + packDoubleX2#, + packFloatX8#, + packDoubleX4#, + packFloatX16#, + packDoubleX8#, + unpackInt8X16#, + unpackInt16X8#, + unpackInt32X4#, + unpackInt64X2#, + unpackInt8X32#, + unpackInt16X16#, + unpackInt32X8#, + unpackInt64X4#, + unpackInt8X64#, + unpackInt16X32#, + unpackInt32X16#, + unpackInt64X8#, + unpackWord8X16#, + unpackWord16X8#, + unpackWord32X4#, + unpackWord64X2#, + unpackWord8X32#, + unpackWord16X16#, + unpackWord32X8#, + unpackWord64X4#, + unpackWord8X64#, + unpackWord16X32#, + unpackWord32X16#, + unpackWord64X8#, + unpackFloatX4#, + unpackDoubleX2#, + unpackFloatX8#, + unpackDoubleX4#, + unpackFloatX16#, + unpackDoubleX8#, + insertInt8X16#, + insertInt16X8#, + insertInt32X4#, + insertInt64X2#, + insertInt8X32#, + insertInt16X16#, + insertInt32X8#, + insertInt64X4#, + insertInt8X64#, + insertInt16X32#, + insertInt32X16#, + insertInt64X8#, + insertWord8X16#, + insertWord16X8#, + insertWord32X4#, + insertWord64X2#, + insertWord8X32#, + insertWord16X16#, + insertWord32X8#, + insertWord64X4#, + insertWord8X64#, + insertWord16X32#, + insertWord32X16#, + insertWord64X8#, + insertFloatX4#, + insertDoubleX2#, + insertFloatX8#, + insertDoubleX4#, + insertFloatX16#, + insertDoubleX8#, + plusInt8X16#, + plusInt16X8#, + plusInt32X4#, + plusInt64X2#, + plusInt8X32#, + plusInt16X16#, + plusInt32X8#, + plusInt64X4#, + plusInt8X64#, + plusInt16X32#, + plusInt32X16#, + plusInt64X8#, + plusWord8X16#, + plusWord16X8#, + plusWord32X4#, + plusWord64X2#, + plusWord8X32#, + plusWord16X16#, + plusWord32X8#, + plusWord64X4#, + plusWord8X64#, + plusWord16X32#, + plusWord32X16#, + plusWord64X8#, + plusFloatX4#, + plusDoubleX2#, + plusFloatX8#, + plusDoubleX4#, + plusFloatX16#, + plusDoubleX8#, + minusInt8X16#, + minusInt16X8#, + minusInt32X4#, + minusInt64X2#, + minusInt8X32#, + minusInt16X16#, + minusInt32X8#, + minusInt64X4#, + minusInt8X64#, + minusInt16X32#, + minusInt32X16#, + minusInt64X8#, + minusWord8X16#, + minusWord16X8#, + minusWord32X4#, + minusWord64X2#, + minusWord8X32#, + minusWord16X16#, + minusWord32X8#, + minusWord64X4#, + minusWord8X64#, + minusWord16X32#, + minusWord32X16#, + minusWord64X8#, + minusFloatX4#, + minusDoubleX2#, + minusFloatX8#, + minusDoubleX4#, + minusFloatX16#, + minusDoubleX8#, + timesInt8X16#, + timesInt16X8#, + timesInt32X4#, + timesInt64X2#, + timesInt8X32#, + timesInt16X16#, + timesInt32X8#, + timesInt64X4#, + timesInt8X64#, + timesInt16X32#, + timesInt32X16#, + timesInt64X8#, + timesWord8X16#, + timesWord16X8#, + timesWord32X4#, + timesWord64X2#, + timesWord8X32#, + timesWord16X16#, + timesWord32X8#, + timesWord64X4#, + timesWord8X64#, + timesWord16X32#, + timesWord32X16#, + timesWord64X8#, + timesFloatX4#, + timesDoubleX2#, + timesFloatX8#, + timesDoubleX4#, + timesFloatX16#, + timesDoubleX8#, + divideFloatX4#, + divideDoubleX2#, + divideFloatX8#, + divideDoubleX4#, + divideFloatX16#, + divideDoubleX8#, + quotInt8X16#, + quotInt16X8#, + quotInt32X4#, + quotInt64X2#, + quotInt8X32#, + quotInt16X16#, + quotInt32X8#, + quotInt64X4#, + quotInt8X64#, + quotInt16X32#, + quotInt32X16#, + quotInt64X8#, + quotWord8X16#, + quotWord16X8#, + quotWord32X4#, + quotWord64X2#, + quotWord8X32#, + quotWord16X16#, + quotWord32X8#, + quotWord64X4#, + quotWord8X64#, + quotWord16X32#, + quotWord32X16#, + quotWord64X8#, + remInt8X16#, + remInt16X8#, + remInt32X4#, + remInt64X2#, + remInt8X32#, + remInt16X16#, + remInt32X8#, + remInt64X4#, + remInt8X64#, + remInt16X32#, + remInt32X16#, + remInt64X8#, + remWord8X16#, + remWord16X8#, + remWord32X4#, + remWord64X2#, + remWord8X32#, + remWord16X16#, + remWord32X8#, + remWord64X4#, + remWord8X64#, + remWord16X32#, + remWord32X16#, + remWord64X8#, + negateInt8X16#, + negateInt16X8#, + negateInt32X4#, + negateInt64X2#, + negateInt8X32#, + negateInt16X16#, + negateInt32X8#, + negateInt64X4#, + negateInt8X64#, + negateInt16X32#, + negateInt32X16#, + negateInt64X8#, + negateFloatX4#, + negateDoubleX2#, + negateFloatX8#, + negateDoubleX4#, + negateFloatX16#, + negateDoubleX8#, + indexInt8X16Array#, + indexInt16X8Array#, + indexInt32X4Array#, + indexInt64X2Array#, + indexInt8X32Array#, + indexInt16X16Array#, + indexInt32X8Array#, + indexInt64X4Array#, + indexInt8X64Array#, + indexInt16X32Array#, + indexInt32X16Array#, + indexInt64X8Array#, + indexWord8X16Array#, + indexWord16X8Array#, + indexWord32X4Array#, + indexWord64X2Array#, + indexWord8X32Array#, + indexWord16X16Array#, + indexWord32X8Array#, + indexWord64X4Array#, + indexWord8X64Array#, + indexWord16X32Array#, + indexWord32X16Array#, + indexWord64X8Array#, + indexFloatX4Array#, + indexDoubleX2Array#, + indexFloatX8Array#, + indexDoubleX4Array#, + indexFloatX16Array#, + indexDoubleX8Array#, + readInt8X16Array#, + readInt16X8Array#, + readInt32X4Array#, + readInt64X2Array#, + readInt8X32Array#, + readInt16X16Array#, + readInt32X8Array#, + readInt64X4Array#, + readInt8X64Array#, + readInt16X32Array#, + readInt32X16Array#, + readInt64X8Array#, + readWord8X16Array#, + readWord16X8Array#, + readWord32X4Array#, + readWord64X2Array#, + readWord8X32Array#, + readWord16X16Array#, + readWord32X8Array#, + readWord64X4Array#, + readWord8X64Array#, + readWord16X32Array#, + readWord32X16Array#, + readWord64X8Array#, + readFloatX4Array#, + readDoubleX2Array#, + readFloatX8Array#, + readDoubleX4Array#, + readFloatX16Array#, + readDoubleX8Array#, + writeInt8X16Array#, + writeInt16X8Array#, + writeInt32X4Array#, + writeInt64X2Array#, + writeInt8X32Array#, + writeInt16X16Array#, + writeInt32X8Array#, + writeInt64X4Array#, + writeInt8X64Array#, + writeInt16X32Array#, + writeInt32X16Array#, + writeInt64X8Array#, + writeWord8X16Array#, + writeWord16X8Array#, + writeWord32X4Array#, + writeWord64X2Array#, + writeWord8X32Array#, + writeWord16X16Array#, + writeWord32X8Array#, + writeWord64X4Array#, + writeWord8X64Array#, + writeWord16X32Array#, + writeWord32X16Array#, + writeWord64X8Array#, + writeFloatX4Array#, + writeDoubleX2Array#, + writeFloatX8Array#, + writeDoubleX4Array#, + writeFloatX16Array#, + writeDoubleX8Array#, + indexInt8X16OffAddr#, + indexInt16X8OffAddr#, + indexInt32X4OffAddr#, + indexInt64X2OffAddr#, + indexInt8X32OffAddr#, + indexInt16X16OffAddr#, + indexInt32X8OffAddr#, + indexInt64X4OffAddr#, + indexInt8X64OffAddr#, + indexInt16X32OffAddr#, + indexInt32X16OffAddr#, + indexInt64X8OffAddr#, + indexWord8X16OffAddr#, + indexWord16X8OffAddr#, + indexWord32X4OffAddr#, + indexWord64X2OffAddr#, + indexWord8X32OffAddr#, + indexWord16X16OffAddr#, + indexWord32X8OffAddr#, + indexWord64X4OffAddr#, + indexWord8X64OffAddr#, + indexWord16X32OffAddr#, + indexWord32X16OffAddr#, + indexWord64X8OffAddr#, + indexFloatX4OffAddr#, + indexDoubleX2OffAddr#, + indexFloatX8OffAddr#, + indexDoubleX4OffAddr#, + indexFloatX16OffAddr#, + indexDoubleX8OffAddr#, + readInt8X16OffAddr#, + readInt16X8OffAddr#, + readInt32X4OffAddr#, + readInt64X2OffAddr#, + readInt8X32OffAddr#, + readInt16X16OffAddr#, + readInt32X8OffAddr#, + readInt64X4OffAddr#, + readInt8X64OffAddr#, + readInt16X32OffAddr#, + readInt32X16OffAddr#, + readInt64X8OffAddr#, + readWord8X16OffAddr#, + readWord16X8OffAddr#, + readWord32X4OffAddr#, + readWord64X2OffAddr#, + readWord8X32OffAddr#, + readWord16X16OffAddr#, + readWord32X8OffAddr#, + readWord64X4OffAddr#, + readWord8X64OffAddr#, + readWord16X32OffAddr#, + readWord32X16OffAddr#, + readWord64X8OffAddr#, + readFloatX4OffAddr#, + readDoubleX2OffAddr#, + readFloatX8OffAddr#, + readDoubleX4OffAddr#, + readFloatX16OffAddr#, + readDoubleX8OffAddr#, + writeInt8X16OffAddr#, + writeInt16X8OffAddr#, + writeInt32X4OffAddr#, + writeInt64X2OffAddr#, + writeInt8X32OffAddr#, + writeInt16X16OffAddr#, + writeInt32X8OffAddr#, + writeInt64X4OffAddr#, + writeInt8X64OffAddr#, + writeInt16X32OffAddr#, + writeInt32X16OffAddr#, + writeInt64X8OffAddr#, + writeWord8X16OffAddr#, + writeWord16X8OffAddr#, + writeWord32X4OffAddr#, + writeWord64X2OffAddr#, + writeWord8X32OffAddr#, + writeWord16X16OffAddr#, + writeWord32X8OffAddr#, + writeWord64X4OffAddr#, + writeWord8X64OffAddr#, + writeWord16X32OffAddr#, + writeWord32X16OffAddr#, + writeWord64X8OffAddr#, + writeFloatX4OffAddr#, + writeDoubleX2OffAddr#, + writeFloatX8OffAddr#, + writeDoubleX4OffAddr#, + writeFloatX16OffAddr#, + writeDoubleX8OffAddr#, + indexInt8ArrayAsInt8X16#, + indexInt16ArrayAsInt16X8#, + indexInt32ArrayAsInt32X4#, + indexInt64ArrayAsInt64X2#, + indexInt8ArrayAsInt8X32#, + indexInt16ArrayAsInt16X16#, + indexInt32ArrayAsInt32X8#, + indexInt64ArrayAsInt64X4#, + indexInt8ArrayAsInt8X64#, + indexInt16ArrayAsInt16X32#, + indexInt32ArrayAsInt32X16#, + indexInt64ArrayAsInt64X8#, + indexWord8ArrayAsWord8X16#, + indexWord16ArrayAsWord16X8#, + indexWord32ArrayAsWord32X4#, + indexWord64ArrayAsWord64X2#, + indexWord8ArrayAsWord8X32#, + indexWord16ArrayAsWord16X16#, + indexWord32ArrayAsWord32X8#, + indexWord64ArrayAsWord64X4#, + indexWord8ArrayAsWord8X64#, + indexWord16ArrayAsWord16X32#, + indexWord32ArrayAsWord32X16#, + indexWord64ArrayAsWord64X8#, + indexFloatArrayAsFloatX4#, + indexDoubleArrayAsDoubleX2#, + indexFloatArrayAsFloatX8#, + indexDoubleArrayAsDoubleX4#, + indexFloatArrayAsFloatX16#, + indexDoubleArrayAsDoubleX8#, + readInt8ArrayAsInt8X16#, + readInt16ArrayAsInt16X8#, + readInt32ArrayAsInt32X4#, + readInt64ArrayAsInt64X2#, + readInt8ArrayAsInt8X32#, + readInt16ArrayAsInt16X16#, + readInt32ArrayAsInt32X8#, + readInt64ArrayAsInt64X4#, + readInt8ArrayAsInt8X64#, + readInt16ArrayAsInt16X32#, + readInt32ArrayAsInt32X16#, + readInt64ArrayAsInt64X8#, + readWord8ArrayAsWord8X16#, + readWord16ArrayAsWord16X8#, + readWord32ArrayAsWord32X4#, + readWord64ArrayAsWord64X2#, + readWord8ArrayAsWord8X32#, + readWord16ArrayAsWord16X16#, + readWord32ArrayAsWord32X8#, + readWord64ArrayAsWord64X4#, + readWord8ArrayAsWord8X64#, + readWord16ArrayAsWord16X32#, + readWord32ArrayAsWord32X16#, + readWord64ArrayAsWord64X8#, + readFloatArrayAsFloatX4#, + readDoubleArrayAsDoubleX2#, + readFloatArrayAsFloatX8#, + readDoubleArrayAsDoubleX4#, + readFloatArrayAsFloatX16#, + readDoubleArrayAsDoubleX8#, + writeInt8ArrayAsInt8X16#, + writeInt16ArrayAsInt16X8#, + writeInt32ArrayAsInt32X4#, + writeInt64ArrayAsInt64X2#, + writeInt8ArrayAsInt8X32#, + writeInt16ArrayAsInt16X16#, + writeInt32ArrayAsInt32X8#, + writeInt64ArrayAsInt64X4#, + writeInt8ArrayAsInt8X64#, + writeInt16ArrayAsInt16X32#, + writeInt32ArrayAsInt32X16#, + writeInt64ArrayAsInt64X8#, + writeWord8ArrayAsWord8X16#, + writeWord16ArrayAsWord16X8#, + writeWord32ArrayAsWord32X4#, + writeWord64ArrayAsWord64X2#, + writeWord8ArrayAsWord8X32#, + writeWord16ArrayAsWord16X16#, + writeWord32ArrayAsWord32X8#, + writeWord64ArrayAsWord64X4#, + writeWord8ArrayAsWord8X64#, + writeWord16ArrayAsWord16X32#, + writeWord32ArrayAsWord32X16#, + writeWord64ArrayAsWord64X8#, + writeFloatArrayAsFloatX4#, + writeDoubleArrayAsDoubleX2#, + writeFloatArrayAsFloatX8#, + writeDoubleArrayAsDoubleX4#, + writeFloatArrayAsFloatX16#, + writeDoubleArrayAsDoubleX8#, + indexInt8OffAddrAsInt8X16#, + indexInt16OffAddrAsInt16X8#, + indexInt32OffAddrAsInt32X4#, + indexInt64OffAddrAsInt64X2#, + indexInt8OffAddrAsInt8X32#, + indexInt16OffAddrAsInt16X16#, + indexInt32OffAddrAsInt32X8#, + indexInt64OffAddrAsInt64X4#, + indexInt8OffAddrAsInt8X64#, + indexInt16OffAddrAsInt16X32#, + indexInt32OffAddrAsInt32X16#, + indexInt64OffAddrAsInt64X8#, + indexWord8OffAddrAsWord8X16#, + indexWord16OffAddrAsWord16X8#, + indexWord32OffAddrAsWord32X4#, + indexWord64OffAddrAsWord64X2#, + indexWord8OffAddrAsWord8X32#, + indexWord16OffAddrAsWord16X16#, + indexWord32OffAddrAsWord32X8#, + indexWord64OffAddrAsWord64X4#, + indexWord8OffAddrAsWord8X64#, + indexWord16OffAddrAsWord16X32#, + indexWord32OffAddrAsWord32X16#, + indexWord64OffAddrAsWord64X8#, + indexFloatOffAddrAsFloatX4#, + indexDoubleOffAddrAsDoubleX2#, + indexFloatOffAddrAsFloatX8#, + indexDoubleOffAddrAsDoubleX4#, + indexFloatOffAddrAsFloatX16#, + indexDoubleOffAddrAsDoubleX8#, + readInt8OffAddrAsInt8X16#, + readInt16OffAddrAsInt16X8#, + readInt32OffAddrAsInt32X4#, + readInt64OffAddrAsInt64X2#, + readInt8OffAddrAsInt8X32#, + readInt16OffAddrAsInt16X16#, + readInt32OffAddrAsInt32X8#, + readInt64OffAddrAsInt64X4#, + readInt8OffAddrAsInt8X64#, + readInt16OffAddrAsInt16X32#, + readInt32OffAddrAsInt32X16#, + readInt64OffAddrAsInt64X8#, + readWord8OffAddrAsWord8X16#, + readWord16OffAddrAsWord16X8#, + readWord32OffAddrAsWord32X4#, + readWord64OffAddrAsWord64X2#, + readWord8OffAddrAsWord8X32#, + readWord16OffAddrAsWord16X16#, + readWord32OffAddrAsWord32X8#, + readWord64OffAddrAsWord64X4#, + readWord8OffAddrAsWord8X64#, + readWord16OffAddrAsWord16X32#, + readWord32OffAddrAsWord32X16#, + readWord64OffAddrAsWord64X8#, + readFloatOffAddrAsFloatX4#, + readDoubleOffAddrAsDoubleX2#, + readFloatOffAddrAsFloatX8#, + readDoubleOffAddrAsDoubleX4#, + readFloatOffAddrAsFloatX16#, + readDoubleOffAddrAsDoubleX8#, + writeInt8OffAddrAsInt8X16#, + writeInt16OffAddrAsInt16X8#, + writeInt32OffAddrAsInt32X4#, + writeInt64OffAddrAsInt64X2#, + writeInt8OffAddrAsInt8X32#, + writeInt16OffAddrAsInt16X16#, + writeInt32OffAddrAsInt32X8#, + writeInt64OffAddrAsInt64X4#, + writeInt8OffAddrAsInt8X64#, + writeInt16OffAddrAsInt16X32#, + writeInt32OffAddrAsInt32X16#, + writeInt64OffAddrAsInt64X8#, + writeWord8OffAddrAsWord8X16#, + writeWord16OffAddrAsWord16X8#, + writeWord32OffAddrAsWord32X4#, + writeWord64OffAddrAsWord64X2#, + writeWord8OffAddrAsWord8X32#, + writeWord16OffAddrAsWord16X16#, + writeWord32OffAddrAsWord32X8#, + writeWord64OffAddrAsWord64X4#, + writeWord8OffAddrAsWord8X64#, + writeWord16OffAddrAsWord16X32#, + writeWord32OffAddrAsWord32X16#, + writeWord64OffAddrAsWord64X8#, + writeFloatOffAddrAsFloatX4#, + writeDoubleOffAddrAsDoubleX2#, + writeFloatOffAddrAsFloatX8#, + writeDoubleOffAddrAsDoubleX4#, + writeFloatOffAddrAsFloatX16#, + writeDoubleOffAddrAsDoubleX8#, + +-- * Prefetch +-- |Prefetch operations: Note how every prefetch operation has a name +-- with the pattern prefetch*N#, where N is either 0,1,2, or 3. +-- +-- This suffix number, N, is the \"locality level\" of the prefetch, following the +-- convention in GCC and other compilers. +-- Higher locality numbers correspond to the memory being loaded in more +-- levels of the cpu cache, and being retained after initial use. The naming +-- convention follows the naming convention of the prefetch intrinsic found +-- in the GCC and Clang C compilers. +-- +-- On the LLVM backend, prefetch*N# uses the LLVM prefetch intrinsic +-- with locality level N. The code generated by LLVM is target architecture +-- dependent, but should agree with the GHC NCG on x86 systems. +-- +-- On the Sparc and PPC native backends, prefetch*N is a No-Op. +-- +-- On the x86 NCG, N=0 will generate prefetchNTA, +-- N=1 generates prefetcht2, N=2 generates prefetcht1, and +-- N=3 generates prefetcht0. +-- +-- For streaming workloads, the prefetch*0 operations are recommended. +-- For workloads which do many reads or writes to a memory location in a short period of time, +-- prefetch*3 operations are recommended. +-- +-- For further reading about prefetch and associated systems performance optimization, +-- the instruction set and optimization manuals by Intel and other CPU vendors are +-- excellent starting place. +-- +-- +-- The \"Intel 64 and IA-32 Architectures Optimization Reference Manual\" is +-- especially a helpful read, even if your software is meant for other CPU +-- architectures or vendor hardware. The manual can be found at +-- http:\/\/www.intel.com\/content\/www\/us\/en\/architecture-and-technology\/64-ia-32-architectures-optimization-manual.html . +-- +-- The @prefetch*@ family of operations has the order of operations +-- determined by passing around the @State#@ token. +-- +-- To get a \"pure\" version of these operations, use @inlinePerformIO@ which is quite safe in this context. +-- +-- It is important to note that while the prefetch operations will never change the +-- answer to a pure computation, They CAN change the memory locations resident +-- in a CPU cache and that may change the performance and timing characteristics +-- of an application. The prefetch operations are marked has_side_effects=True +-- to reflect that these operations have side effects with respect to the runtime +-- performance characteristics of the resulting code. Additionally, if the prefetchValue +-- operations did not have this attribute, GHC does a float out transformation that +-- results in a let\/app violation, at least with the current design. +-- + + + prefetchByteArray3#, + prefetchMutableByteArray3#, + prefetchAddr3#, + prefetchValue3#, + prefetchByteArray2#, + prefetchMutableByteArray2#, + prefetchAddr2#, + prefetchValue2#, + prefetchByteArray1#, + prefetchMutableByteArray1#, + prefetchAddr1#, + prefetchValue1#, + prefetchByteArray0#, + prefetchMutableByteArray0#, + prefetchAddr0#, + prefetchValue0#, +) where + +{- +has_side_effects = False +out_of_line = False +can_fail = False +commutable = False +code_size = { primOpCodeSizeDefault } +strictness = { \ arity -> mkClosedStrictSig (replicate arity topDmd) topRes } +fixity = Nothing +llvm_only = False + +-} +import GHC.Types (Coercible) +default () +data Char# + +gtChar# :: Char# -> Char# -> Int# +gtChar# = gtChar# + +geChar# :: Char# -> Char# -> Int# +geChar# = geChar# + +eqChar# :: Char# -> Char# -> Int# +eqChar# = eqChar# + +neChar# :: Char# -> Char# -> Int# +neChar# = neChar# + +ltChar# :: Char# -> Char# -> Int# +ltChar# = ltChar# + +leChar# :: Char# -> Char# -> Int# +leChar# = leChar# + +ord# :: Char# -> Int# +ord# = ord# + +data Int# + +infixl 6 +# +(+#) :: Int# -> Int# -> Int# +(+#) = (+#) + +infixl 6 -# +(-#) :: Int# -> Int# -> Int# +(-#) = (-#) + +-- |Low word of signed integer multiply. + +infixl 7 *# +(*#) :: 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 recommmended 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. +-- + +mulIntMayOflo# :: Int# -> Int# -> Int# +mulIntMayOflo# = mulIntMayOflo# + +-- |Rounds towards zero. + +quotInt# :: Int# -> Int# -> Int# +quotInt# = quotInt# + +-- |Satisfies @(quotInt\# x y) *\# y +\# (remInt\# x y) == x@. + +remInt# :: Int# -> Int# -> Int# +remInt# = remInt# + +-- |Rounds towards zero. + +quotRemInt# :: Int# -> Int# -> (# Int#,Int# #) +quotRemInt# = quotRemInt# + +andI# :: Int# -> Int# -> Int# +andI# = andI# + +orI# :: Int# -> Int# -> Int# +orI# = orI# + +xorI# :: Int# -> Int# -> Int# +xorI# = xorI# + +notI# :: Int# -> Int# +notI# = notI# + +negateInt# :: Int# -> Int# +negateInt# = negateInt# + +-- |Add signed integers reporting overflow. +-- First member of result is the sum truncated to an @Int#@; +-- second member is zero if the true sum fits in an @Int#@, +-- nonzero if overflow occurred (the sum is either too large +-- or too small to fit in an @Int#@). + +addIntC# :: Int# -> Int# -> (# Int#,Int# #) +addIntC# = addIntC# + +-- |Subtract signed integers reporting overflow. +-- First member of result is the difference truncated to an @Int#@; +-- second member is zero if the true difference fits in an @Int#@, +-- nonzero if overflow occurred (the difference is either too large +-- or too small to fit in an @Int#@). + +subIntC# :: Int# -> Int# -> (# Int#,Int# #) +subIntC# = subIntC# + +infix 4 ># +(>#) :: Int# -> Int# -> Int# +(>#) = (>#) + +infix 4 >=# +(>=#) :: Int# -> Int# -> Int# +(>=#) = (>=#) + +infix 4 ==# +(==#) :: Int# -> Int# -> Int# +(==#) = (==#) + +infix 4 /=# +(/=#) :: Int# -> Int# -> Int# +(/=#) = (/=#) + +infix 4 <# +(<#) :: Int# -> Int# -> Int# +(<#) = (<#) + +infix 4 <=# +(<=#) :: Int# -> Int# -> Int# +(<=#) = (<=#) + +chr# :: Int# -> Char# +chr# = chr# + +int2Word# :: Int# -> Word# +int2Word# = int2Word# + +int2Float# :: Int# -> Float# +int2Float# = int2Float# + +int2Double# :: Int# -> Double# +int2Double# = int2Double# + +word2Float# :: Word# -> Float# +word2Float# = word2Float# + +word2Double# :: Word# -> Double# +word2Double# = word2Double# + +-- |Shift left. Result undefined if shift amount is not +-- in the range 0 to word size - 1 inclusive. + +uncheckedIShiftL# :: Int# -> Int# -> Int# +uncheckedIShiftL# = uncheckedIShiftL# + +-- |Shift right arithmetic. Result undefined if shift amount is not +-- in the range 0 to word size - 1 inclusive. + +uncheckedIShiftRA# :: Int# -> Int# -> Int# +uncheckedIShiftRA# = uncheckedIShiftRA# + +-- |Shift right logical. Result undefined if shift amount is not +-- in the range 0 to word size - 1 inclusive. + +uncheckedIShiftRL# :: Int# -> Int# -> Int# +uncheckedIShiftRL# = uncheckedIShiftRL# + +data Word# + +plusWord# :: Word# -> Word# -> Word# +plusWord# = plusWord# + +-- |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. + +subWordC# :: Word# -> Word# -> (# Word#,Int# #) +subWordC# = subWordC# + +plusWord2# :: Word# -> Word# -> (# Word#,Word# #) +plusWord2# = plusWord2# + +minusWord# :: Word# -> Word# -> Word# +minusWord# = minusWord# + +timesWord# :: Word# -> Word# -> Word# +timesWord# = timesWord# + +timesWord2# :: Word# -> Word# -> (# Word#,Word# #) +timesWord2# = timesWord2# + +quotWord# :: Word# -> Word# -> Word# +quotWord# = quotWord# + +remWord# :: Word# -> Word# -> Word# +remWord# = remWord# + +quotRemWord# :: Word# -> Word# -> (# Word#,Word# #) +quotRemWord# = quotRemWord# + +quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #) +quotRemWord2# = quotRemWord2# + +and# :: Word# -> Word# -> Word# +and# = and# + +or# :: Word# -> Word# -> Word# +or# = or# + +xor# :: Word# -> Word# -> Word# +xor# = xor# + +not# :: Word# -> Word# +not# = not# + +-- |Shift left logical. Result undefined if shift amount is not +-- in the range 0 to word size - 1 inclusive. + +uncheckedShiftL# :: Word# -> Int# -> Word# +uncheckedShiftL# = uncheckedShiftL# + +-- |Shift right logical. Result undefined if shift amount is not +-- in the range 0 to word size - 1 inclusive. + +uncheckedShiftRL# :: Word# -> Int# -> Word# +uncheckedShiftRL# = uncheckedShiftRL# + +word2Int# :: Word# -> Int# +word2Int# = word2Int# + +gtWord# :: Word# -> Word# -> Int# +gtWord# = gtWord# + +geWord# :: Word# -> Word# -> Int# +geWord# = geWord# + +eqWord# :: Word# -> Word# -> Int# +eqWord# = eqWord# + +neWord# :: Word# -> Word# -> Int# +neWord# = neWord# + +ltWord# :: Word# -> Word# -> Int# +ltWord# = ltWord# + +leWord# :: Word# -> Word# -> Int# +leWord# = leWord# + +-- |Count the number of set bits in the lower 8 bits of a word. + +popCnt8# :: Word# -> Word# +popCnt8# = popCnt8# + +-- |Count the number of set bits in the lower 16 bits of a word. + +popCnt16# :: Word# -> Word# +popCnt16# = popCnt16# + +-- |Count the number of set bits in the lower 32 bits of a word. + +popCnt32# :: Word# -> Word# +popCnt32# = popCnt32# + +-- |Count the number of set bits in a 64-bit word. + +popCnt64# :: Word# -> Word# +popCnt64# = popCnt64# + +-- |Count the number of set bits in a word. + +popCnt# :: Word# -> Word# +popCnt# = popCnt# + +-- |Count leading zeros in the lower 8 bits of a word. + +clz8# :: Word# -> Word# +clz8# = clz8# + +-- |Count leading zeros in the lower 16 bits of a word. + +clz16# :: Word# -> Word# +clz16# = clz16# + +-- |Count leading zeros in the lower 32 bits of a word. + +clz32# :: Word# -> Word# +clz32# = clz32# + +-- |Count leading zeros in a 64-bit word. + +clz64# :: Word# -> Word# +clz64# = clz64# + +-- |Count leading zeros in a word. + +clz# :: Word# -> Word# +clz# = clz# + +-- |Count trailing zeros in the lower 8 bits of a word. + +ctz8# :: Word# -> Word# +ctz8# = ctz8# + +-- |Count trailing zeros in the lower 16 bits of a word. + +ctz16# :: Word# -> Word# +ctz16# = ctz16# + +-- |Count trailing zeros in the lower 32 bits of a word. + +ctz32# :: Word# -> Word# +ctz32# = ctz32# + +-- |Count trailing zeros in a 64-bit word. + +ctz64# :: Word# -> Word# +ctz64# = ctz64# + +-- |Count trailing zeros in a word. + +ctz# :: Word# -> Word# +ctz# = ctz# + +-- |Swap bytes in the lower 16 bits of a word. The higher bytes are undefined. + +byteSwap16# :: Word# -> Word# +byteSwap16# = byteSwap16# + +-- |Swap bytes in the lower 32 bits of a word. The higher bytes are undefined. + +byteSwap32# :: Word# -> Word# +byteSwap32# = byteSwap32# + +-- |Swap bytes in a 64 bits of a word. + +byteSwap64# :: Word# -> Word# +byteSwap64# = byteSwap64# + +-- |Swap bytes in a word. + +byteSwap# :: Word# -> Word# +byteSwap# = byteSwap# + +narrow8Int# :: Int# -> Int# +narrow8Int# = narrow8Int# + +narrow16Int# :: Int# -> Int# +narrow16Int# = narrow16Int# + +narrow32Int# :: Int# -> Int# +narrow32Int# = narrow32Int# + +narrow8Word# :: Word# -> Word# +narrow8Word# = narrow8Word# + +narrow16Word# :: Word# -> Word# +narrow16Word# = narrow16Word# + +narrow32Word# :: Word# -> Word# +narrow32Word# = narrow32Word# + +data Double# + +infix 4 >## +(>##) :: Double# -> Double# -> Int# +(>##) = (>##) + +infix 4 >=## +(>=##) :: Double# -> Double# -> Int# +(>=##) = (>=##) + +infix 4 ==## +(==##) :: Double# -> Double# -> Int# +(==##) = (==##) + +infix 4 /=## +(/=##) :: Double# -> Double# -> Int# +(/=##) = (/=##) + +infix 4 <## +(<##) :: Double# -> Double# -> Int# +(<##) = (<##) + +infix 4 <=## +(<=##) :: Double# -> Double# -> Int# +(<=##) = (<=##) + +infixl 6 +## +(+##) :: Double# -> Double# -> Double# +(+##) = (+##) + +infixl 6 -## +(-##) :: Double# -> Double# -> Double# +(-##) = (-##) + +infixl 7 *## +(*##) :: Double# -> Double# -> Double# +(*##) = (*##) + +infixl 7 /## +(/##) :: Double# -> Double# -> Double# +(/##) = (/##) + +negateDouble# :: Double# -> Double# +negateDouble# = negateDouble# + +-- |Truncates a @Double#@ value to the nearest @Int#@. +-- Results are undefined if the truncation if truncation yields +-- a value outside the range of @Int#@. + +double2Int# :: Double# -> Int# +double2Int# = double2Int# + +double2Float# :: Double# -> Float# +double2Float# = double2Float# + +expDouble# :: Double# -> Double# +expDouble# = expDouble# + +logDouble# :: Double# -> Double# +logDouble# = logDouble# + +sqrtDouble# :: Double# -> Double# +sqrtDouble# = sqrtDouble# + +sinDouble# :: Double# -> Double# +sinDouble# = sinDouble# + +cosDouble# :: Double# -> Double# +cosDouble# = cosDouble# + +tanDouble# :: Double# -> Double# +tanDouble# = tanDouble# + +asinDouble# :: Double# -> Double# +asinDouble# = asinDouble# + +acosDouble# :: Double# -> Double# +acosDouble# = acosDouble# + +atanDouble# :: Double# -> Double# +atanDouble# = atanDouble# + +sinhDouble# :: Double# -> Double# +sinhDouble# = sinhDouble# + +coshDouble# :: Double# -> Double# +coshDouble# = coshDouble# + +tanhDouble# :: Double# -> Double# +tanhDouble# = tanhDouble# + +-- |Exponentiation. + +(**##) :: Double# -> Double# -> Double# +(**##) = (**##) + +-- |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_2Int# :: Double# -> (# Int#,Word#,Word#,Int# #) +decodeDouble_2Int# = decodeDouble_2Int# + +-- |Decode @Double\#@ into mantissa and base-2 exponent. + +decodeDouble_Int64# :: Double# -> (# Int#,Int# #) +decodeDouble_Int64# = decodeDouble_Int64# + +data Float# + +gtFloat# :: Float# -> Float# -> Int# +gtFloat# = gtFloat# + +geFloat# :: Float# -> Float# -> Int# +geFloat# = geFloat# + +eqFloat# :: Float# -> Float# -> Int# +eqFloat# = eqFloat# + +neFloat# :: Float# -> Float# -> Int# +neFloat# = neFloat# + +ltFloat# :: Float# -> Float# -> Int# +ltFloat# = ltFloat# + +leFloat# :: Float# -> Float# -> Int# +leFloat# = leFloat# + +plusFloat# :: Float# -> Float# -> Float# +plusFloat# = plusFloat# + +minusFloat# :: Float# -> Float# -> Float# +minusFloat# = minusFloat# + +timesFloat# :: Float# -> Float# -> Float# +timesFloat# = timesFloat# + +divideFloat# :: Float# -> Float# -> Float# +divideFloat# = divideFloat# + +negateFloat# :: Float# -> Float# +negateFloat# = negateFloat# + +-- |Truncates a @Float#@ value to the nearest @Int#@. +-- Results are undefined if the truncation if truncation yields +-- a value outside the range of @Int#@. + +float2Int# :: Float# -> Int# +float2Int# = float2Int# + +expFloat# :: Float# -> Float# +expFloat# = expFloat# + +logFloat# :: Float# -> Float# +logFloat# = logFloat# + +sqrtFloat# :: Float# -> Float# +sqrtFloat# = sqrtFloat# + +sinFloat# :: Float# -> Float# +sinFloat# = sinFloat# + +cosFloat# :: Float# -> Float# +cosFloat# = cosFloat# + +tanFloat# :: Float# -> Float# +tanFloat# = tanFloat# + +asinFloat# :: Float# -> Float# +asinFloat# = asinFloat# + +acosFloat# :: Float# -> Float# +acosFloat# = acosFloat# + +atanFloat# :: Float# -> Float# +atanFloat# = atanFloat# + +sinhFloat# :: Float# -> Float# +sinhFloat# = sinhFloat# + +coshFloat# :: Float# -> Float# +coshFloat# = coshFloat# + +tanhFloat# :: Float# -> Float# +tanhFloat# = tanhFloat# + +powerFloat# :: Float# -> Float# -> Float# +powerFloat# = powerFloat# + +float2Double# :: Float# -> Double# +float2Double# = float2Double# + +-- |Convert to integers. +-- First @Int\#@ in result is the mantissa; second is the exponent. + +decodeFloat_Int# :: Float# -> (# Int#,Int# #) +decodeFloat_Int# = decodeFloat_Int# + +data Array# a + +data MutableArray# s 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. + +newArray# :: Int# -> a -> State# s -> (# State# s,MutableArray# s a #) +newArray# = newArray# + +sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int# +sameMutableArray# = sameMutableArray# + +-- |Read from specified index of mutable array. Result is not yet evaluated. + +readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s,a #) +readArray# = readArray# + +-- |Write to specified index of mutable array. + +writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s +writeArray# = writeArray# + +-- |Return the number of elements in the array. + +sizeofArray# :: Array# a -> Int# +sizeofArray# = sizeofArray# + +-- |Return the number of elements in the array. + +sizeofMutableArray# :: MutableArray# s a -> Int# +sizeofMutableArray# = sizeofMutableArray# + +-- |Read from specified index of immutable array. Result is packaged into +-- an unboxed singleton; the result itself is not yet evaluated. + +indexArray# :: Array# a -> Int# -> (# a #) +indexArray# = indexArray# + +-- |Make a mutable array immutable, without copying. + +unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s,Array# a #) +unsafeFreezeArray# = unsafeFreezeArray# + +-- |Make an immutable array mutable, without copying. + +unsafeThawArray# :: Array# a -> State# s -> (# State# s,MutableArray# s a #) +unsafeThawArray# = unsafeThawArray# + +-- |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. + +copyArray# :: Array# a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s +copyArray# = copyArray# + +-- |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. + +copyMutableArray# :: MutableArray# s a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s +copyMutableArray# = copyMutableArray# + +-- |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. + +cloneArray# :: Array# a -> Int# -> Int# -> Array# a +cloneArray# = cloneArray# + +-- |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# s a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #) +cloneMutableArray# = cloneMutableArray# + +-- |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# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #) +freezeArray# = freezeArray# + +-- |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# s -> (# State# s,MutableArray# s a #) +thawArray# = thawArray# + +-- |Unsafe, machine-level atomic compare and swap on an element within an Array. + +casArray# :: MutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #) +casArray# = casArray# + +data SmallArray# a + +data SmallMutableArray# s 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. + +newSmallArray# :: Int# -> a -> State# s -> (# State# s,SmallMutableArray# s a #) +newSmallArray# = newSmallArray# + +sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int# +sameSmallMutableArray# = sameSmallMutableArray# + +-- |Read from specified index of mutable array. Result is not yet evaluated. + +readSmallArray# :: SmallMutableArray# s a -> Int# -> State# s -> (# State# s,a #) +readSmallArray# = readSmallArray# + +-- |Write to specified index of mutable array. + +writeSmallArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> State# s +writeSmallArray# = writeSmallArray# + +-- |Return the number of elements in the array. + +sizeofSmallArray# :: SmallArray# a -> Int# +sizeofSmallArray# = sizeofSmallArray# + +-- |Return the number of elements in the array. + +sizeofSmallMutableArray# :: SmallMutableArray# s a -> Int# +sizeofSmallMutableArray# = sizeofSmallMutableArray# + +-- |Read from specified index of immutable array. Result is packaged into +-- an unboxed singleton; the result itself is not yet evaluated. + +indexSmallArray# :: SmallArray# a -> Int# -> (# a #) +indexSmallArray# = indexSmallArray# + +-- |Make a mutable array immutable, without copying. + +unsafeFreezeSmallArray# :: SmallMutableArray# s a -> State# s -> (# State# s,SmallArray# a #) +unsafeFreezeSmallArray# = unsafeFreezeSmallArray# + +-- |Make an immutable array mutable, without copying. + +unsafeThawSmallArray# :: SmallArray# a -> State# s -> (# State# s,SmallMutableArray# s a #) +unsafeThawSmallArray# = unsafeThawSmallArray# + +-- |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. + +copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s +copySmallArray# = copySmallArray# + +-- |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. + +copySmallMutableArray# :: SmallMutableArray# s a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s +copySmallMutableArray# = copySmallMutableArray# + +-- |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. + +cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a +cloneSmallArray# = cloneSmallArray# + +-- |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# s a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #) +cloneSmallMutableArray# = cloneSmallMutableArray# + +-- |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# s a -> Int# -> Int# -> State# s -> (# State# s,SmallArray# a #) +freezeSmallArray# = freezeSmallArray# + +-- |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# s -> (# State# s,SmallMutableArray# s a #) +thawSmallArray# = thawSmallArray# + +-- |Unsafe, machine-level atomic compare and swap on an element within an array. + +casSmallArray# :: SmallMutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #) +casSmallArray# = casSmallArray# + +data ByteArray# + +data MutableByteArray# s + +-- |Create a new mutable byte array of specified size (in bytes), in +-- the specified state thread. + +newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) +newByteArray# = newByteArray# + +-- |Create a mutable byte array that the GC guarantees not to move. + +newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) +newPinnedByteArray# = newPinnedByteArray# + +-- |Create a mutable byte array, aligned by the specified amount, that the GC guarantees not to move. + +newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s,MutableByteArray# s #) +newAlignedPinnedByteArray# = newAlignedPinnedByteArray# + +-- |Intended for use with pinned arrays; otherwise very unsafe! + +byteArrayContents# :: ByteArray# -> Addr# +byteArrayContents# = byteArrayContents# + +sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int# +sameMutableByteArray# = sameMutableByteArray# + +-- |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 by @sizeofMutableArray\#@. + +shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s +shrinkMutableByteArray# = shrinkMutableByteArray# + +-- |Resize (unpinned) mutable byte array to new specified size (in bytes). +-- The returned @MutableByteArray\#@ is either the original +-- @MutableByteArray\#@ resized in-place or, if not possible, a newly +-- allocated (unpinned) @MutableByteArray\#@ (with the original content +-- copied over). +-- +-- To avoid undefined behaviour, the original @MutableByteArray\#@ shall +-- not be accessed anymore after a @resizeMutableByteArray\#@ has been +-- performed. Moreover, no reference to the old one should be kept in order +-- to allow garbage collection of the original @MutableByteArray\#@ in +-- case a new @MutableByteArray\#@ had to be allocated. + +resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #) +resizeMutableByteArray# = resizeMutableByteArray# + +-- |Make a mutable byte array immutable, without copying. + +unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #) +unsafeFreezeByteArray# = unsafeFreezeByteArray# + +-- |Return the size of the array in bytes. + +sizeofByteArray# :: ByteArray# -> Int# +sizeofByteArray# = sizeofByteArray# + +-- |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. See @getSizeofMutableByteArray@. + +sizeofMutableByteArray# :: MutableByteArray# s -> Int# +sizeofMutableByteArray# = sizeofMutableByteArray# + +-- |Return the number of elements in the array. + +getSizeofMutableByteArray# :: MutableByteArray# s -> State# s -> (# State# s,Int# #) +getSizeofMutableByteArray# = getSizeofMutableByteArray# + +-- |Read 8-bit character; offset in bytes. + +indexCharArray# :: ByteArray# -> Int# -> Char# +indexCharArray# = indexCharArray# + +-- |Read 31-bit character; offset in 4-byte words. + +indexWideCharArray# :: ByteArray# -> Int# -> Char# +indexWideCharArray# = indexWideCharArray# + +indexIntArray# :: ByteArray# -> Int# -> Int# +indexIntArray# = indexIntArray# + +indexWordArray# :: ByteArray# -> Int# -> Word# +indexWordArray# = indexWordArray# + +indexAddrArray# :: ByteArray# -> Int# -> Addr# +indexAddrArray# = indexAddrArray# + +indexFloatArray# :: ByteArray# -> Int# -> Float# +indexFloatArray# = indexFloatArray# + +indexDoubleArray# :: ByteArray# -> Int# -> Double# +indexDoubleArray# = indexDoubleArray# + +indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a +indexStablePtrArray# = indexStablePtrArray# + +-- |Read 8-bit integer; offset in bytes. + +indexInt8Array# :: ByteArray# -> Int# -> Int# +indexInt8Array# = indexInt8Array# + +-- |Read 16-bit integer; offset in 16-bit words. + +indexInt16Array# :: ByteArray# -> Int# -> Int# +indexInt16Array# = indexInt16Array# + +-- |Read 32-bit integer; offset in 32-bit words. + +indexInt32Array# :: ByteArray# -> Int# -> Int# +indexInt32Array# = indexInt32Array# + +-- |Read 64-bit integer; offset in 64-bit words. + +indexInt64Array# :: ByteArray# -> Int# -> Int# +indexInt64Array# = indexInt64Array# + +-- |Read 8-bit word; offset in bytes. + +indexWord8Array# :: ByteArray# -> Int# -> Word# +indexWord8Array# = indexWord8Array# + +-- |Read 16-bit word; offset in 16-bit words. + +indexWord16Array# :: ByteArray# -> Int# -> Word# +indexWord16Array# = indexWord16Array# + +-- |Read 32-bit word; offset in 32-bit words. + +indexWord32Array# :: ByteArray# -> Int# -> Word# +indexWord32Array# = indexWord32Array# + +-- |Read 64-bit word; offset in 64-bit words. + +indexWord64Array# :: ByteArray# -> Int# -> Word# +indexWord64Array# = indexWord64Array# + +-- |Read 8-bit character; offset in bytes. + +readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) +readCharArray# = readCharArray# + +-- |Read 31-bit character; offset in 4-byte words. + +readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) +readWideCharArray# = readWideCharArray# + +-- |Read intger; offset in words. + +readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readIntArray# = readIntArray# + +-- |Read word; offset in words. + +readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWordArray# = readWordArray# + +readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #) +readAddrArray# = readAddrArray# + +readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #) +readFloatArray# = readFloatArray# + +readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #) +readDoubleArray# = readDoubleArray# + +readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #) +readStablePtrArray# = readStablePtrArray# + +readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readInt8Array# = readInt8Array# + +readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readInt16Array# = readInt16Array# + +readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readInt32Array# = readInt32Array# + +readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readInt64Array# = readInt64Array# + +readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWord8Array# = readWord8Array# + +readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWord16Array# = readWord16Array# + +readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWord32Array# = readWord32Array# + +readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWord64Array# = readWord64Array# + +-- |Write 8-bit character; offset in bytes. + +writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s +writeCharArray# = writeCharArray# + +-- |Write 31-bit character; offset in 4-byte words. + +writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s +writeWideCharArray# = writeWideCharArray# + +writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeIntArray# = writeIntArray# + +writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWordArray# = writeWordArray# + +writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s +writeAddrArray# = writeAddrArray# + +writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s +writeFloatArray# = writeFloatArray# + +writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s +writeDoubleArray# = writeDoubleArray# + +writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s +writeStablePtrArray# = writeStablePtrArray# + +writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeInt8Array# = writeInt8Array# + +writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeInt16Array# = writeInt16Array# + +writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeInt32Array# = writeInt32Array# + +writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeInt64Array# = writeInt64Array# + +writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWord8Array# = writeWord8Array# + +writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWord16Array# = writeWord16Array# + +writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWord32Array# = writeWord32Array# + +writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWord64Array# = writeWord64Array# + +-- |Copy a range of the ByteArray# to the specified region in the MutableByteArray#. +-- 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. + +copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +copyByteArray# = copyByteArray# + +-- |Copy a range of the first MutableByteArray# to the specified region in the second MutableByteArray#. +-- Both arrays must fully contain the specified ranges, but this is not checked. + +copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +copyMutableByteArray# = copyMutableByteArray# + +-- |Copy a range of the ByteArray# to the memory range starting at the Addr#. +-- The ByteArray# and the memory region at Addr# must fully contain the +-- specified ranges, but this is not checked. The Addr# must not point into the +-- ByteArray# (e.g. if the ByteArray# were pinned), but this is not checked +-- either. + +copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s +copyByteArrayToAddr# = copyByteArrayToAddr# + +-- |Copy a range of the MutableByteArray# to the memory range starting at the +-- Addr#. The MutableByteArray# and the memory region at Addr# must fully +-- contain the specified ranges, but this is not checked. The Addr# must not +-- point into the MutableByteArray# (e.g. if the MutableByteArray# were +-- pinned), but this is not checked either. + +copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s +copyMutableByteArrayToAddr# = copyMutableByteArrayToAddr# + +-- |Copy a memory range starting at the Addr# to the specified range in the +-- MutableByteArray#. The memory region at Addr# and the ByteArray# must fully +-- contain the specified ranges, but this is not checked. The Addr# must not +-- point into the MutableByteArray# (e.g. if the MutableByteArray# were pinned), +-- but this is not checked either. + +copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +copyAddrToByteArray# = copyAddrToByteArray# + +-- |Set the range of the MutableByteArray# to the specified character. + +setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s +setByteArray# = setByteArray# + +-- |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. + +atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +atomicReadIntArray# = atomicReadIntArray# + +-- |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. + +atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +atomicWriteIntArray# = atomicWriteIntArray# + +-- |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. + +casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #) +casIntArray# = casIntArray# + +-- |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. + +fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) +fetchAddIntArray# = fetchAddIntArray# + +-- |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. + +fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) +fetchSubIntArray# = fetchSubIntArray# + +-- |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. + +fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) +fetchAndIntArray# = fetchAndIntArray# + +-- |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. + +fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) +fetchNandIntArray# = fetchNandIntArray# + +-- |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. + +fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) +fetchOrIntArray# = fetchOrIntArray# + +-- |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. + +fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) +fetchXorIntArray# = fetchXorIntArray# + +data ArrayArray# + +data MutableArrayArray# s + +-- |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. + +newArrayArray# :: Int# -> State# s -> (# State# s,MutableArrayArray# s #) +newArrayArray# = newArrayArray# + +sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int# +sameMutableArrayArray# = sameMutableArrayArray# + +-- |Make a mutable array of arrays immutable, without copying. + +unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s,ArrayArray# #) +unsafeFreezeArrayArray# = unsafeFreezeArrayArray# + +-- |Return the number of elements in the array. + +sizeofArrayArray# :: ArrayArray# -> Int# +sizeofArrayArray# = sizeofArrayArray# + +-- |Return the number of elements in the array. + +sizeofMutableArrayArray# :: MutableArrayArray# s -> Int# +sizeofMutableArrayArray# = sizeofMutableArrayArray# + +indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray# +indexByteArrayArray# = indexByteArrayArray# + +indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray# +indexArrayArrayArray# = indexArrayArrayArray# + +readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ByteArray# #) +readByteArrayArray# = readByteArrayArray# + +readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #) +readMutableByteArrayArray# = readMutableByteArrayArray# + +readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ArrayArray# #) +readArrayArrayArray# = readArrayArrayArray# + +readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableArrayArray# s #) +readMutableArrayArrayArray# = readMutableArrayArrayArray# + +writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s +writeByteArrayArray# = writeByteArrayArray# + +writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s +writeMutableByteArrayArray# = writeMutableByteArrayArray# + +writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s +writeArrayArrayArray# = writeArrayArrayArray# + +writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s +writeMutableArrayArrayArray# = writeMutableArrayArrayArray# + +-- |Copy a range of the ArrayArray# to the specified region in the MutableArrayArray#. +-- 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. + +copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s +copyArrayArray# = copyArrayArray# + +-- |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. + +copyMutableArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s +copyMutableArrayArray# = copyMutableArrayArray# + +-- | An arbitrary machine address assumed to point outside +-- the garbage-collected heap. + +data Addr# + +-- | The null address. + +nullAddr# :: Addr# +nullAddr# = nullAddr# + +plusAddr# :: Addr# -> Int# -> Addr# +plusAddr# = plusAddr# + +-- |Result is meaningless if two @Addr\#@s are so far apart that their +-- difference doesn\'t fit in an @Int\#@. + +minusAddr# :: Addr# -> Addr# -> Int# +minusAddr# = minusAddr# + +-- |Return the remainder when the @Addr\#@ arg, treated like an @Int\#@, +-- is divided by the @Int\#@ arg. + +remAddr# :: Addr# -> Int# -> Int# +remAddr# = remAddr# + +-- |Coerce directly from address to int. Strongly deprecated. + +addr2Int# :: Addr# -> Int# +addr2Int# = addr2Int# + +-- |Coerce directly from int to address. Strongly deprecated. + +int2Addr# :: Int# -> Addr# +int2Addr# = int2Addr# + +gtAddr# :: Addr# -> Addr# -> Int# +gtAddr# = gtAddr# + +geAddr# :: Addr# -> Addr# -> Int# +geAddr# = geAddr# + +eqAddr# :: Addr# -> Addr# -> Int# +eqAddr# = eqAddr# + +neAddr# :: Addr# -> Addr# -> Int# +neAddr# = neAddr# + +ltAddr# :: Addr# -> Addr# -> Int# +ltAddr# = ltAddr# + +leAddr# :: Addr# -> Addr# -> Int# +leAddr# = leAddr# + +-- |Reads 8-bit character; offset in bytes. + +indexCharOffAddr# :: Addr# -> Int# -> Char# +indexCharOffAddr# = indexCharOffAddr# + +-- |Reads 31-bit character; offset in 4-byte words. + +indexWideCharOffAddr# :: Addr# -> Int# -> Char# +indexWideCharOffAddr# = indexWideCharOffAddr# + +indexIntOffAddr# :: Addr# -> Int# -> Int# +indexIntOffAddr# = indexIntOffAddr# + +indexWordOffAddr# :: Addr# -> Int# -> Word# +indexWordOffAddr# = indexWordOffAddr# + +indexAddrOffAddr# :: Addr# -> Int# -> Addr# +indexAddrOffAddr# = indexAddrOffAddr# + +indexFloatOffAddr# :: Addr# -> Int# -> Float# +indexFloatOffAddr# = indexFloatOffAddr# + +indexDoubleOffAddr# :: Addr# -> Int# -> Double# +indexDoubleOffAddr# = indexDoubleOffAddr# + +indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a +indexStablePtrOffAddr# = indexStablePtrOffAddr# + +indexInt8OffAddr# :: Addr# -> Int# -> Int# +indexInt8OffAddr# = indexInt8OffAddr# + +indexInt16OffAddr# :: Addr# -> Int# -> Int# +indexInt16OffAddr# = indexInt16OffAddr# + +indexInt32OffAddr# :: Addr# -> Int# -> Int# +indexInt32OffAddr# = indexInt32OffAddr# + +indexInt64OffAddr# :: Addr# -> Int# -> Int# +indexInt64OffAddr# = indexInt64OffAddr# + +indexWord8OffAddr# :: Addr# -> Int# -> Word# +indexWord8OffAddr# = indexWord8OffAddr# + +indexWord16OffAddr# :: Addr# -> Int# -> Word# +indexWord16OffAddr# = indexWord16OffAddr# + +indexWord32OffAddr# :: Addr# -> Int# -> Word# +indexWord32OffAddr# = indexWord32OffAddr# + +indexWord64OffAddr# :: Addr# -> Int# -> Word# +indexWord64OffAddr# = indexWord64OffAddr# + +-- |Reads 8-bit character; offset in bytes. + +readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #) +readCharOffAddr# = readCharOffAddr# + +-- |Reads 31-bit character; offset in 4-byte words. + +readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #) +readWideCharOffAddr# = readWideCharOffAddr# + +readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readIntOffAddr# = readIntOffAddr# + +readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWordOffAddr# = readWordOffAddr# + +readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #) +readAddrOffAddr# = readAddrOffAddr# + +readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #) +readFloatOffAddr# = readFloatOffAddr# + +readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #) +readDoubleOffAddr# = readDoubleOffAddr# + +readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #) +readStablePtrOffAddr# = readStablePtrOffAddr# + +readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readInt8OffAddr# = readInt8OffAddr# + +readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readInt16OffAddr# = readInt16OffAddr# + +readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readInt32OffAddr# = readInt32OffAddr# + +readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readInt64OffAddr# = readInt64OffAddr# + +readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWord8OffAddr# = readWord8OffAddr# + +readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWord16OffAddr# = readWord16OffAddr# + +readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWord32OffAddr# = readWord32OffAddr# + +readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWord64OffAddr# = readWord64OffAddr# + +writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s +writeCharOffAddr# = writeCharOffAddr# + +writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s +writeWideCharOffAddr# = writeWideCharOffAddr# + +writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeIntOffAddr# = writeIntOffAddr# + +writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWordOffAddr# = writeWordOffAddr# + +writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s +writeAddrOffAddr# = writeAddrOffAddr# + +writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s +writeFloatOffAddr# = writeFloatOffAddr# + +writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s +writeDoubleOffAddr# = writeDoubleOffAddr# + +writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s +writeStablePtrOffAddr# = writeStablePtrOffAddr# + +writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeInt8OffAddr# = writeInt8OffAddr# + +writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeInt16OffAddr# = writeInt16OffAddr# + +writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeInt32OffAddr# = writeInt32OffAddr# + +writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeInt64OffAddr# = writeInt64OffAddr# + +writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWord8OffAddr# = writeWord8OffAddr# + +writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWord16OffAddr# = writeWord16OffAddr# + +writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWord32OffAddr# = writeWord32OffAddr# + +writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWord64OffAddr# = writeWord64OffAddr# + +-- |A @MutVar\#@ behaves like a single-element mutable array. + +data MutVar# s a + +-- |Create @MutVar\#@ with specified initial value in specified state thread. + +newMutVar# :: a -> State# s -> (# State# s,MutVar# s a #) +newMutVar# = newMutVar# + +-- |Read contents of @MutVar\#@. Result is not yet evaluated. + +readMutVar# :: MutVar# s a -> State# s -> (# State# s,a #) +readMutVar# = readMutVar# + +-- |Write contents of @MutVar\#@. + +writeMutVar# :: MutVar# s a -> a -> State# s -> State# s +writeMutVar# = writeMutVar# + +sameMutVar# :: MutVar# s a -> MutVar# s a -> Int# +sameMutVar# = sameMutVar# + +atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s,c #) +atomicModifyMutVar# = atomicModifyMutVar# + +casMutVar# :: MutVar# s a -> a -> a -> State# s -> (# State# s,Int#,a #) +casMutVar# = casMutVar# + +catch# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +catch# = catch# + +raise# :: b -> o +raise# = raise# + +raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld),b #) +raiseIO# = raiseIO# + +maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +maskAsyncExceptions# = maskAsyncExceptions# + +maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +maskUninterruptible# = maskUninterruptible# + +unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +unmaskAsyncExceptions# = unmaskAsyncExceptions# + +getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #) +getMaskingState# = getMaskingState# + +data TVar# s a + +atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +atomically# = atomically# + +retry# :: State# (RealWorld) -> (# State# (RealWorld),a #) +retry# = retry# + +catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +catchRetry# = catchRetry# + +catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +catchSTM# = catchSTM# + +check# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> State# (RealWorld) +check# = check# + +-- |Create a new @TVar\#@ holding a specified initial value. + +newTVar# :: a -> State# s -> (# State# s,TVar# s a #) +newTVar# = newTVar# + +-- |Read contents of @TVar\#@. Result is not yet evaluated. + +readTVar# :: TVar# s a -> State# s -> (# State# s,a #) +readTVar# = readTVar# + +-- |Read contents of @TVar\#@ outside an STM transaction + +readTVarIO# :: TVar# s a -> State# s -> (# State# s,a #) +readTVarIO# = readTVarIO# + +-- |Write contents of @TVar\#@. + +writeTVar# :: TVar# s a -> a -> State# s -> State# s +writeTVar# = writeTVar# + +sameTVar# :: TVar# s a -> TVar# s a -> Int# +sameTVar# = sameTVar# + +-- | A shared mutable variable (/not/ the same as a @MutVar\#@!). +-- (Note: in a non-concurrent implementation, @(MVar\# a)@ can be +-- represented by @(MutVar\# (Maybe a))@.) + +data MVar# s a + +-- |Create new @MVar\#@; initially empty. + +newMVar# :: State# s -> (# State# s,MVar# s a #) +newMVar# = newMVar# + +-- |If @MVar\#@ is empty, block until it becomes full. +-- Then remove and return its contents, and set it empty. + +takeMVar# :: MVar# s a -> State# s -> (# State# s,a #) +takeMVar# = takeMVar# + +-- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined. +-- Otherwise, return with integer 1 and contents of @MVar\#@, and set @MVar\#@ empty. + +tryTakeMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #) +tryTakeMVar# = tryTakeMVar# + +-- |If @MVar\#@ is full, block until it becomes empty. +-- Then store value arg as its new contents. + +putMVar# :: MVar# s a -> a -> State# s -> State# s +putMVar# = putMVar# + +-- |If @MVar\#@ is full, immediately return with integer 0. +-- Otherwise, store value arg as @MVar\#@\'s new contents, and return with integer 1. + +tryPutMVar# :: MVar# s a -> a -> State# s -> (# State# s,Int# #) +tryPutMVar# = tryPutMVar# + +-- |If @MVar\#@ is empty, block until it becomes full. +-- Then read its contents without modifying the MVar, without possibility +-- of intervention from other threads. + +readMVar# :: MVar# s a -> State# s -> (# State# s,a #) +readMVar# = readMVar# + +-- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined. +-- Otherwise, return with integer 1 and contents of @MVar\#@. + +tryReadMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #) +tryReadMVar# = tryReadMVar# + +sameMVar# :: MVar# s a -> MVar# s a -> Int# +sameMVar# = sameMVar# + +-- |Return 1 if @MVar\#@ is empty; 0 otherwise. + +isEmptyMVar# :: MVar# s a -> State# s -> (# State# s,Int# #) +isEmptyMVar# = isEmptyMVar# + +-- |Sleep specified number of microseconds. + +delay# :: Int# -> State# s -> State# s +delay# = delay# + +-- |Block until input is available on specified file descriptor. + +waitRead# :: Int# -> State# s -> State# s +waitRead# = waitRead# + +-- |Block until output is possible on specified file descriptor. + +waitWrite# :: Int# -> State# s -> State# s +waitWrite# = waitWrite# + +-- | @State\#@ is the primitive, unlifted type of states. It has +-- one type parameter, thus @State\# RealWorld@, or @State\# s@, +-- where s is a type variable. The only purpose of the type parameter +-- is to keep different state threads separate. It is represented by +-- nothing at all. + +data State# s + +-- | @RealWorld@ is deeply magical. It is /primitive/, but it is not +-- /unlifted/ (hence @ptrArg@). We never manipulate values of type +-- @RealWorld@; it\'s only used in the type system, to parameterise @State\#@. + +data RealWorld + +-- |(In a non-concurrent implementation, this can be a singleton +-- type, whose (unique) value is returned by @myThreadId\#@. The +-- other operations can be omitted.) + +data ThreadId# + +fork# :: a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) +fork# = fork# + +forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) +forkOn# = forkOn# + +killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld) +killThread# = killThread# + +yield# :: State# (RealWorld) -> State# (RealWorld) +yield# = yield# + +myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) +myThreadId# = myThreadId# + +labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld) +labelThread# = labelThread# + +isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #) +isCurrentThreadBound# = isCurrentThreadBound# + +noDuplicate# :: State# (RealWorld) -> State# (RealWorld) +noDuplicate# = noDuplicate# + +threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #) +threadStatus# = threadStatus# + +data Weak# b + +mkWeak# :: o -> b -> (State# (RealWorld) -> (# State# (RealWorld),c #)) -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #) +mkWeak# = mkWeak# + +mkWeakNoFinalizer# :: o -> b -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #) +mkWeakNoFinalizer# = mkWeakNoFinalizer# + +-- | @addCFinalizerToWeak# fptr ptr flag eptr w@ attaches a C +-- function pointer @fptr@ to a weak pointer @w@ as a finalizer. If +-- @flag@ is zero, @fptr@ will be called with one argument, +-- @ptr@. Otherwise, it will be called with two arguments, +-- @eptr@ and @ptr@. @addCFinalizerToWeak#@ returns +-- 1 on success, or 0 if @w@ is already dead. + +addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# (RealWorld) -> (# State# (RealWorld),Int# #) +addCFinalizerToWeak# = addCFinalizerToWeak# + +deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,a #) +deRefWeak# = deRefWeak# + +-- | Finalize a weak pointer. The return value is an unboxed tuple +-- containing the new state of the world and an \"unboxed Maybe\", +-- represented by an @Int#@ and a (possibly invalid) finalization +-- action. An @Int#@ of @1@ indicates that the finalizer is valid. The +-- return value @b@ from the finalizer should be ignored. + +finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),b #) #) +finalizeWeak# = finalizeWeak# + +touch# :: o -> State# (RealWorld) -> State# (RealWorld) +touch# = touch# + +data StablePtr# a + +data StableName# a + +makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a #) +makeStablePtr# = makeStablePtr# + +deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld),a #) +deRefStablePtr# = deRefStablePtr# + +eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int# +eqStablePtr# = eqStablePtr# + +makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld),StableName# a #) +makeStableName# = makeStableName# + +eqStableName# :: StableName# a -> StableName# b -> Int# +eqStableName# = eqStableName# + +stableNameToInt# :: StableName# a -> Int# +stableNameToInt# = stableNameToInt# + +reallyUnsafePtrEquality# :: a -> a -> Int# +reallyUnsafePtrEquality# = reallyUnsafePtrEquality# + +par# :: a -> Int# +par# = par# + +spark# :: a -> State# s -> (# State# s,a #) +spark# = spark# + +seq# :: a -> State# s -> (# State# s,a #) +seq# = seq# + +getSpark# :: State# s -> (# State# s,Int#,a #) +getSpark# = getSpark# + +-- | Returns the number of sparks in the local spark pool. + +numSparks# :: State# s -> (# State# s,Int# #) +numSparks# = numSparks# + +dataToTag# :: a -> Int# +dataToTag# = dataToTag# + +tagToEnum# :: Int# -> a +tagToEnum# = let x = x in x + +-- | Primitive bytecode type. + +data BCO# + +-- | Convert an @Addr\#@ to a followable Any type. + +addrToAny# :: Addr# -> (# a #) +addrToAny# = addrToAny# + +-- | Wrap a BCO in a @AP_UPD@ thunk which will be updated with the value of +-- the BCO when evaluated. + +mkApUpd0# :: BCO# -> (# a #) +mkApUpd0# = mkApUpd0# + +-- | @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 in @instrs@, and a static reference table usage bitmap given by +-- @bitmap@. + +newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO# #) +newBCO# = newBCO# + +unpackClosure# :: a -> (# Addr#,Array# b,ByteArray# #) +unpackClosure# = unpackClosure# + +getApStackVal# :: a -> Int# -> (# Int#,b #) +getApStackVal# = getApStackVal# + +getCCSOf# :: a -> State# s -> (# State# s,Addr# #) +getCCSOf# = getCCSOf# + +-- | Returns the current @CostCentreStack@ (value is @NULL@ if +-- not profiling). Takes a dummy argument which can be used to +-- avoid the call to @getCCCS\#@ being floated out by the +-- simplifier, which would result in an uninformative stack +-- (\"CAF\"). + +getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #) +getCurrentCCS# = getCurrentCCS# + +-- | 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. + +clearCCS# :: (State# s -> (# State# s,a #)) -> State# s -> (# State# s,a #) +clearCCS# = clearCCS# + +-- | The type constructor @Proxy#@ is used to bear witness to some +-- type variable. It\'s used when you want to pass around proxy values +-- for doing things like modelling type applications. A @Proxy#@ +-- is not only unboxed, it also has a polymorphic kind, and has no +-- runtime representation, being totally free. + +data Proxy# a + +-- | Witness for an unboxed @Proxy#@ value, which has no runtime +-- representation. + +proxy# :: Proxy# a +proxy# = proxy# + +-- | The value of @seq a b@ is bottom if @a@ is bottom, and +-- otherwise equal to @b@. @seq@ is usually introduced to +-- improve performance by avoiding unneeded laziness. +-- +-- A note on evaluation order: the expression @seq a b@ does +-- /not/ guarantee that @a@ will be evaluated before @b@. +-- The only guarantee given by @seq@ is that the both @a@ +-- and @b@ will be evaluated before @seq@ returns a value. +-- In particular, this means that @b@ may be evaluated before +-- @a@. If you need to guarantee a specific order of evaluation, +-- you must use the function @pseq@ from the \"parallel\" package. + +seq :: a -> b -> b +seq = seq + +-- | The type constructor @Any@ is type to which you can unsafely coerce any +-- lifted type, and back. +-- +-- * It is lifted, and hence represented by a pointer +-- +-- * It does not claim to be a /data/ type, and that\'s important for +-- the code generator, because the code gen may /enter/ a data value +-- but never enters a function value. +-- +-- It\'s also used to instantiate un-constrained type variables after type +-- checking. For example, @length@ has type +-- +-- @length :: forall a. [a] -> Int@ +-- +-- and the list datacon for the empty list has type +-- +-- @[] :: forall a. [a]@ +-- +-- In order to compose these two terms as @length []@ a type +-- application is required, but there is no constraint on the +-- choice. In this situation GHC uses @Any@: +-- +-- @length (Any *) ([] (Any *))@ +-- +-- Above, we print kinds explicitly, as if with +-- @-fprint-explicit-kinds@. +-- +-- Note that @Any@ is kind polymorphic; its kind is thus +-- @forall k. k@. + +data Any + +-- | The kind @AnyK@ is the kind level counterpart to @Any@. In a +-- kind polymorphic setting, a similar example to the length of the empty +-- list can be given at the type level: +-- +-- @type family Length (l :: [k]) :: Nat@ +-- @type instance Length [] = Zero@ +-- +-- When @Length@ is applied to the empty (promoted) list it will have +-- the kind @Length AnyK []@. +-- +-- @AnyK@ is currently not exported and cannot be used directly, but +-- you might see it in debug output from the compiler. +-- + +data AnyK + +-- | The function @unsafeCoerce\#@ allows you to side-step the typechecker entirely. That +-- is, it allows you to coerce any type into any other type. If you use this function, +-- you had better get it right, otherwise segmentation faults await. It is generally +-- used when you want to write a program that you know is well-typed, but where Haskell\'s +-- type system is not expressive enough to prove that it is well typed. +-- +-- The following uses of @unsafeCoerce\#@ are supposed to work (i.e. not lead to +-- spurious compile-time or run-time crashes): +-- +-- * Casting any lifted type to @Any@ +-- +-- * Casting @Any@ back to the real type +-- +-- * Casting an unboxed type to another unboxed type of the same size +-- (but not coercions between floating-point and integral types) +-- +-- * Casting between two types that have the same runtime representation. One case is when +-- the two types differ only in \"phantom\" type parameters, for example +-- @Ptr Int@ to @Ptr Float@, or @[Int]@ to @[Float]@ when the list is +-- known to be empty. Also, a @newtype@ of a type @T@ has the same representation +-- at runtime as @T@. +-- +-- Other uses of @unsafeCoerce\#@ are undefined. In particular, you should not use +-- @unsafeCoerce\#@ to cast a T to an algebraic data type D, unless T is also +-- an algebraic data type. For example, do not cast @Int->Int@ to @Bool@, even if +-- you later cast that @Bool@ back to @Int->Int@ before applying it. The reasons +-- have to do with GHC\'s internal representation details (for the congnoscenti, data values +-- can be entered but function closures cannot). If you want a safe type to cast things +-- to, use @Any@, which is not an algebraic data type. +-- +-- + +unsafeCoerce# :: a -> b +unsafeCoerce# = unsafeCoerce# + +-- | 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. + +traceEvent# :: Addr# -> State# s -> State# s +traceEvent# = traceEvent# + +-- | 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. + +traceMarker# :: Addr# -> State# s -> State# s +traceMarker# = traceMarker# + +-- | The function @coerce@ 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. +-- + +coerce :: Coercible a b => a -> b +coerce = coerce + +data Int8X16# + +data Int16X8# + +data Int32X4# + +data Int64X2# + +data Int8X32# + +data Int16X16# + +data Int32X8# + +data Int64X4# + +data Int8X64# + +data Int16X32# + +data Int32X16# + +data Int64X8# + +data Word8X16# + +data Word16X8# + +data Word32X4# + +data Word64X2# + +data Word8X32# + +data Word16X16# + +data Word32X8# + +data Word64X4# + +data Word8X64# + +data Word16X32# + +data Word32X16# + +data Word64X8# + +data FloatX4# + +data DoubleX2# + +data FloatX8# + +data DoubleX4# + +data FloatX16# + +data DoubleX8# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt8X16# :: Int# -> Int8X16# +broadcastInt8X16# = broadcastInt8X16# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt16X8# :: Int# -> Int16X8# +broadcastInt16X8# = broadcastInt16X8# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt32X4# :: Int# -> Int32X4# +broadcastInt32X4# = broadcastInt32X4# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt64X2# :: Int# -> Int64X2# +broadcastInt64X2# = broadcastInt64X2# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt8X32# :: Int# -> Int8X32# +broadcastInt8X32# = broadcastInt8X32# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt16X16# :: Int# -> Int16X16# +broadcastInt16X16# = broadcastInt16X16# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt32X8# :: Int# -> Int32X8# +broadcastInt32X8# = broadcastInt32X8# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt64X4# :: Int# -> Int64X4# +broadcastInt64X4# = broadcastInt64X4# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt8X64# :: Int# -> Int8X64# +broadcastInt8X64# = broadcastInt8X64# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt16X32# :: Int# -> Int16X32# +broadcastInt16X32# = broadcastInt16X32# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt32X16# :: Int# -> Int32X16# +broadcastInt32X16# = broadcastInt32X16# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt64X8# :: Int# -> Int64X8# +broadcastInt64X8# = broadcastInt64X8# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord8X16# :: Word# -> Word8X16# +broadcastWord8X16# = broadcastWord8X16# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord16X8# :: Word# -> Word16X8# +broadcastWord16X8# = broadcastWord16X8# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord32X4# :: Word# -> Word32X4# +broadcastWord32X4# = broadcastWord32X4# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord64X2# :: Word# -> Word64X2# +broadcastWord64X2# = broadcastWord64X2# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord8X32# :: Word# -> Word8X32# +broadcastWord8X32# = broadcastWord8X32# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord16X16# :: Word# -> Word16X16# +broadcastWord16X16# = broadcastWord16X16# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord32X8# :: Word# -> Word32X8# +broadcastWord32X8# = broadcastWord32X8# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord64X4# :: Word# -> Word64X4# +broadcastWord64X4# = broadcastWord64X4# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord8X64# :: Word# -> Word8X64# +broadcastWord8X64# = broadcastWord8X64# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord16X32# :: Word# -> Word16X32# +broadcastWord16X32# = broadcastWord16X32# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord32X16# :: Word# -> Word32X16# +broadcastWord32X16# = broadcastWord32X16# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord64X8# :: Word# -> Word64X8# +broadcastWord64X8# = broadcastWord64X8# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastFloatX4# :: Float# -> FloatX4# +broadcastFloatX4# = broadcastFloatX4# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastDoubleX2# :: Double# -> DoubleX2# +broadcastDoubleX2# = broadcastDoubleX2# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastFloatX8# :: Float# -> FloatX8# +broadcastFloatX8# = broadcastFloatX8# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastDoubleX4# :: Double# -> DoubleX4# +broadcastDoubleX4# = broadcastDoubleX4# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastFloatX16# :: Float# -> FloatX16# +broadcastFloatX16# = broadcastFloatX16# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastDoubleX8# :: Double# -> DoubleX8# +broadcastDoubleX8# = broadcastDoubleX8# + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt8X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X16# +packInt8X16# = packInt8X16# + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt16X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X8# +packInt16X8# = packInt16X8# + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt32X4# :: (# Int#,Int#,Int#,Int# #) -> Int32X4# +packInt32X4# = packInt32X4# + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt64X2# :: (# Int#,Int# #) -> Int64X2# +packInt64X2# = packInt64X2# + +-- | 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# +packInt8X32# = packInt8X32# + +-- | 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# +packInt16X16# = packInt16X16# + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt32X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int32X8# +packInt32X8# = packInt32X8# + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt64X4# :: (# Int#,Int#,Int#,Int# #) -> Int64X4# +packInt64X4# = packInt64X4# + +-- | 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# +packInt8X64# = packInt8X64# + +-- | 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# +packInt16X32# = packInt16X32# + +-- | 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# +packInt32X16# = packInt32X16# + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt64X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int64X8# +packInt64X8# = packInt64X8# + +-- | 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# +packWord8X16# = packWord8X16# + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord16X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X8# +packWord16X8# = packWord16X8# + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord32X4# :: (# Word#,Word#,Word#,Word# #) -> Word32X4# +packWord32X4# = packWord32X4# + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord64X2# :: (# Word#,Word# #) -> Word64X2# +packWord64X2# = packWord64X2# + +-- | 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# +packWord8X32# = packWord8X32# + +-- | 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# +packWord16X16# = packWord16X16# + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord32X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word32X8# +packWord32X8# = packWord32X8# + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord64X4# :: (# Word#,Word#,Word#,Word# #) -> Word64X4# +packWord64X4# = packWord64X4# + +-- | 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# +packWord8X64# = packWord8X64# + +-- | 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# +packWord16X32# = packWord16X32# + +-- | 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# +packWord32X16# = packWord32X16# + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord64X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word64X8# +packWord64X8# = packWord64X8# + +-- | Pack the elements of an unboxed tuple into a vector. + +packFloatX4# :: (# Float#,Float#,Float#,Float# #) -> FloatX4# +packFloatX4# = packFloatX4# + +-- | Pack the elements of an unboxed tuple into a vector. + +packDoubleX2# :: (# Double#,Double# #) -> DoubleX2# +packDoubleX2# = packDoubleX2# + +-- | Pack the elements of an unboxed tuple into a vector. + +packFloatX8# :: (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -> FloatX8# +packFloatX8# = packFloatX8# + +-- | Pack the elements of an unboxed tuple into a vector. + +packDoubleX4# :: (# Double#,Double#,Double#,Double# #) -> DoubleX4# +packDoubleX4# = packDoubleX4# + +-- | 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# +packFloatX16# = packFloatX16# + +-- | Pack the elements of an unboxed tuple into a vector. + +packDoubleX8# :: (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #) -> DoubleX8# +packDoubleX8# = packDoubleX8# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt8X16# :: Int8X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) +unpackInt8X16# = unpackInt8X16# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt16X8# :: Int16X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) +unpackInt16X8# = unpackInt16X8# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt32X4# :: Int32X4# -> (# Int#,Int#,Int#,Int# #) +unpackInt32X4# = unpackInt32X4# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt64X2# :: Int64X2# -> (# Int#,Int# #) +unpackInt64X2# = unpackInt64X2# + +-- | 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# #) +unpackInt8X32# = unpackInt8X32# + +-- | 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# #) +unpackInt16X16# = unpackInt16X16# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt32X8# :: Int32X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) +unpackInt32X8# = unpackInt32X8# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt64X4# :: Int64X4# -> (# Int#,Int#,Int#,Int# #) +unpackInt64X4# = unpackInt64X4# + +-- | 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# #) +unpackInt8X64# = unpackInt8X64# + +-- | 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# #) +unpackInt16X32# = unpackInt16X32# + +-- | 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# #) +unpackInt32X16# = unpackInt32X16# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt64X8# :: Int64X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) +unpackInt64X8# = unpackInt64X8# + +-- | 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# #) +unpackWord8X16# = unpackWord8X16# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord16X8# :: Word16X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) +unpackWord16X8# = unpackWord16X8# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord32X4# :: Word32X4# -> (# Word#,Word#,Word#,Word# #) +unpackWord32X4# = unpackWord32X4# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord64X2# :: Word64X2# -> (# Word#,Word# #) +unpackWord64X2# = unpackWord64X2# + +-- | 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# #) +unpackWord8X32# = unpackWord8X32# + +-- | 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# #) +unpackWord16X16# = unpackWord16X16# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord32X8# :: Word32X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) +unpackWord32X8# = unpackWord32X8# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord64X4# :: Word64X4# -> (# Word#,Word#,Word#,Word# #) +unpackWord64X4# = unpackWord64X4# + +-- | 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# #) +unpackWord8X64# = unpackWord8X64# + +-- | 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# #) +unpackWord16X32# = unpackWord16X32# + +-- | 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# #) +unpackWord32X16# = unpackWord32X16# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord64X8# :: Word64X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) +unpackWord64X8# = unpackWord64X8# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackFloatX4# :: FloatX4# -> (# Float#,Float#,Float#,Float# #) +unpackFloatX4# = unpackFloatX4# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackDoubleX2# :: DoubleX2# -> (# Double#,Double# #) +unpackDoubleX2# = unpackDoubleX2# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackFloatX8# :: FloatX8# -> (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) +unpackFloatX8# = unpackFloatX8# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackDoubleX4# :: DoubleX4# -> (# Double#,Double#,Double#,Double# #) +unpackDoubleX4# = unpackDoubleX4# + +-- | 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# #) +unpackFloatX16# = unpackFloatX16# + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackDoubleX8# :: DoubleX8# -> (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #) +unpackDoubleX8# = unpackDoubleX8# + +-- | Insert a scalar at the given position in a vector. + +insertInt8X16# :: Int8X16# -> Int# -> Int# -> Int8X16# +insertInt8X16# = insertInt8X16# + +-- | Insert a scalar at the given position in a vector. + +insertInt16X8# :: Int16X8# -> Int# -> Int# -> Int16X8# +insertInt16X8# = insertInt16X8# + +-- | Insert a scalar at the given position in a vector. + +insertInt32X4# :: Int32X4# -> Int# -> Int# -> Int32X4# +insertInt32X4# = insertInt32X4# + +-- | Insert a scalar at the given position in a vector. + +insertInt64X2# :: Int64X2# -> Int# -> Int# -> Int64X2# +insertInt64X2# = insertInt64X2# + +-- | Insert a scalar at the given position in a vector. + +insertInt8X32# :: Int8X32# -> Int# -> Int# -> Int8X32# +insertInt8X32# = insertInt8X32# + +-- | Insert a scalar at the given position in a vector. + +insertInt16X16# :: Int16X16# -> Int# -> Int# -> Int16X16# +insertInt16X16# = insertInt16X16# + +-- | Insert a scalar at the given position in a vector. + +insertInt32X8# :: Int32X8# -> Int# -> Int# -> Int32X8# +insertInt32X8# = insertInt32X8# + +-- | Insert a scalar at the given position in a vector. + +insertInt64X4# :: Int64X4# -> Int# -> Int# -> Int64X4# +insertInt64X4# = insertInt64X4# + +-- | Insert a scalar at the given position in a vector. + +insertInt8X64# :: Int8X64# -> Int# -> Int# -> Int8X64# +insertInt8X64# = insertInt8X64# + +-- | Insert a scalar at the given position in a vector. + +insertInt16X32# :: Int16X32# -> Int# -> Int# -> Int16X32# +insertInt16X32# = insertInt16X32# + +-- | Insert a scalar at the given position in a vector. + +insertInt32X16# :: Int32X16# -> Int# -> Int# -> Int32X16# +insertInt32X16# = insertInt32X16# + +-- | Insert a scalar at the given position in a vector. + +insertInt64X8# :: Int64X8# -> Int# -> Int# -> Int64X8# +insertInt64X8# = insertInt64X8# + +-- | Insert a scalar at the given position in a vector. + +insertWord8X16# :: Word8X16# -> Word# -> Int# -> Word8X16# +insertWord8X16# = insertWord8X16# + +-- | Insert a scalar at the given position in a vector. + +insertWord16X8# :: Word16X8# -> Word# -> Int# -> Word16X8# +insertWord16X8# = insertWord16X8# + +-- | Insert a scalar at the given position in a vector. + +insertWord32X4# :: Word32X4# -> Word# -> Int# -> Word32X4# +insertWord32X4# = insertWord32X4# + +-- | Insert a scalar at the given position in a vector. + +insertWord64X2# :: Word64X2# -> Word# -> Int# -> Word64X2# +insertWord64X2# = insertWord64X2# + +-- | Insert a scalar at the given position in a vector. + +insertWord8X32# :: Word8X32# -> Word# -> Int# -> Word8X32# +insertWord8X32# = insertWord8X32# + +-- | Insert a scalar at the given position in a vector. + +insertWord16X16# :: Word16X16# -> Word# -> Int# -> Word16X16# +insertWord16X16# = insertWord16X16# + +-- | Insert a scalar at the given position in a vector. + +insertWord32X8# :: Word32X8# -> Word# -> Int# -> Word32X8# +insertWord32X8# = insertWord32X8# + +-- | Insert a scalar at the given position in a vector. + +insertWord64X4# :: Word64X4# -> Word# -> Int# -> Word64X4# +insertWord64X4# = insertWord64X4# + +-- | Insert a scalar at the given position in a vector. + +insertWord8X64# :: Word8X64# -> Word# -> Int# -> Word8X64# +insertWord8X64# = insertWord8X64# + +-- | Insert a scalar at the given position in a vector. + +insertWord16X32# :: Word16X32# -> Word# -> Int# -> Word16X32# +insertWord16X32# = insertWord16X32# + +-- | Insert a scalar at the given position in a vector. + +insertWord32X16# :: Word32X16# -> Word# -> Int# -> Word32X16# +insertWord32X16# = insertWord32X16# + +-- | Insert a scalar at the given position in a vector. + +insertWord64X8# :: Word64X8# -> Word# -> Int# -> Word64X8# +insertWord64X8# = insertWord64X8# + +-- | Insert a scalar at the given position in a vector. + +insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4# +insertFloatX4# = insertFloatX4# + +-- | Insert a scalar at the given position in a vector. + +insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2# +insertDoubleX2# = insertDoubleX2# + +-- | Insert a scalar at the given position in a vector. + +insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8# +insertFloatX8# = insertFloatX8# + +-- | Insert a scalar at the given position in a vector. + +insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4# +insertDoubleX4# = insertDoubleX4# + +-- | Insert a scalar at the given position in a vector. + +insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16# +insertFloatX16# = insertFloatX16# + +-- | Insert a scalar at the given position in a vector. + +insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8# +insertDoubleX8# = insertDoubleX8# + +-- | Add two vectors element-wise. + +plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# +plusInt8X16# = plusInt8X16# + +-- | Add two vectors element-wise. + +plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# +plusInt16X8# = plusInt16X8# + +-- | Add two vectors element-wise. + +plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# +plusInt32X4# = plusInt32X4# + +-- | Add two vectors element-wise. + +plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# +plusInt64X2# = plusInt64X2# + +-- | Add two vectors element-wise. + +plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# +plusInt8X32# = plusInt8X32# + +-- | Add two vectors element-wise. + +plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# +plusInt16X16# = plusInt16X16# + +-- | Add two vectors element-wise. + +plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# +plusInt32X8# = plusInt32X8# + +-- | Add two vectors element-wise. + +plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# +plusInt64X4# = plusInt64X4# + +-- | Add two vectors element-wise. + +plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# +plusInt8X64# = plusInt8X64# + +-- | Add two vectors element-wise. + +plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# +plusInt16X32# = plusInt16X32# + +-- | Add two vectors element-wise. + +plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# +plusInt32X16# = plusInt32X16# + +-- | Add two vectors element-wise. + +plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# +plusInt64X8# = plusInt64X8# + +-- | Add two vectors element-wise. + +plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# +plusWord8X16# = plusWord8X16# + +-- | Add two vectors element-wise. + +plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# +plusWord16X8# = plusWord16X8# + +-- | Add two vectors element-wise. + +plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# +plusWord32X4# = plusWord32X4# + +-- | Add two vectors element-wise. + +plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# +plusWord64X2# = plusWord64X2# + +-- | Add two vectors element-wise. + +plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# +plusWord8X32# = plusWord8X32# + +-- | Add two vectors element-wise. + +plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# +plusWord16X16# = plusWord16X16# + +-- | Add two vectors element-wise. + +plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# +plusWord32X8# = plusWord32X8# + +-- | Add two vectors element-wise. + +plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# +plusWord64X4# = plusWord64X4# + +-- | Add two vectors element-wise. + +plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# +plusWord8X64# = plusWord8X64# + +-- | Add two vectors element-wise. + +plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# +plusWord16X32# = plusWord16X32# + +-- | Add two vectors element-wise. + +plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# +plusWord32X16# = plusWord32X16# + +-- | Add two vectors element-wise. + +plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# +plusWord64X8# = plusWord64X8# + +-- | Add two vectors element-wise. + +plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# +plusFloatX4# = plusFloatX4# + +-- | Add two vectors element-wise. + +plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# +plusDoubleX2# = plusDoubleX2# + +-- | Add two vectors element-wise. + +plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# +plusFloatX8# = plusFloatX8# + +-- | Add two vectors element-wise. + +plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# +plusDoubleX4# = plusDoubleX4# + +-- | Add two vectors element-wise. + +plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# +plusFloatX16# = plusFloatX16# + +-- | Add two vectors element-wise. + +plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# +plusDoubleX8# = plusDoubleX8# + +-- | Subtract two vectors element-wise. + +minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# +minusInt8X16# = minusInt8X16# + +-- | Subtract two vectors element-wise. + +minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# +minusInt16X8# = minusInt16X8# + +-- | Subtract two vectors element-wise. + +minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# +minusInt32X4# = minusInt32X4# + +-- | Subtract two vectors element-wise. + +minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# +minusInt64X2# = minusInt64X2# + +-- | Subtract two vectors element-wise. + +minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# +minusInt8X32# = minusInt8X32# + +-- | Subtract two vectors element-wise. + +minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# +minusInt16X16# = minusInt16X16# + +-- | Subtract two vectors element-wise. + +minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# +minusInt32X8# = minusInt32X8# + +-- | Subtract two vectors element-wise. + +minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# +minusInt64X4# = minusInt64X4# + +-- | Subtract two vectors element-wise. + +minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# +minusInt8X64# = minusInt8X64# + +-- | Subtract two vectors element-wise. + +minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# +minusInt16X32# = minusInt16X32# + +-- | Subtract two vectors element-wise. + +minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# +minusInt32X16# = minusInt32X16# + +-- | Subtract two vectors element-wise. + +minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# +minusInt64X8# = minusInt64X8# + +-- | Subtract two vectors element-wise. + +minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# +minusWord8X16# = minusWord8X16# + +-- | Subtract two vectors element-wise. + +minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# +minusWord16X8# = minusWord16X8# + +-- | Subtract two vectors element-wise. + +minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# +minusWord32X4# = minusWord32X4# + +-- | Subtract two vectors element-wise. + +minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# +minusWord64X2# = minusWord64X2# + +-- | Subtract two vectors element-wise. + +minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# +minusWord8X32# = minusWord8X32# + +-- | Subtract two vectors element-wise. + +minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# +minusWord16X16# = minusWord16X16# + +-- | Subtract two vectors element-wise. + +minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# +minusWord32X8# = minusWord32X8# + +-- | Subtract two vectors element-wise. + +minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# +minusWord64X4# = minusWord64X4# + +-- | Subtract two vectors element-wise. + +minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# +minusWord8X64# = minusWord8X64# + +-- | Subtract two vectors element-wise. + +minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# +minusWord16X32# = minusWord16X32# + +-- | Subtract two vectors element-wise. + +minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# +minusWord32X16# = minusWord32X16# + +-- | Subtract two vectors element-wise. + +minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# +minusWord64X8# = minusWord64X8# + +-- | Subtract two vectors element-wise. + +minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# +minusFloatX4# = minusFloatX4# + +-- | Subtract two vectors element-wise. + +minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# +minusDoubleX2# = minusDoubleX2# + +-- | Subtract two vectors element-wise. + +minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# +minusFloatX8# = minusFloatX8# + +-- | Subtract two vectors element-wise. + +minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# +minusDoubleX4# = minusDoubleX4# + +-- | Subtract two vectors element-wise. + +minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# +minusFloatX16# = minusFloatX16# + +-- | Subtract two vectors element-wise. + +minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# +minusDoubleX8# = minusDoubleX8# + +-- | Multiply two vectors element-wise. + +timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# +timesInt8X16# = timesInt8X16# + +-- | Multiply two vectors element-wise. + +timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# +timesInt16X8# = timesInt16X8# + +-- | Multiply two vectors element-wise. + +timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# +timesInt32X4# = timesInt32X4# + +-- | Multiply two vectors element-wise. + +timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# +timesInt64X2# = timesInt64X2# + +-- | Multiply two vectors element-wise. + +timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# +timesInt8X32# = timesInt8X32# + +-- | Multiply two vectors element-wise. + +timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# +timesInt16X16# = timesInt16X16# + +-- | Multiply two vectors element-wise. + +timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# +timesInt32X8# = timesInt32X8# + +-- | Multiply two vectors element-wise. + +timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# +timesInt64X4# = timesInt64X4# + +-- | Multiply two vectors element-wise. + +timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# +timesInt8X64# = timesInt8X64# + +-- | Multiply two vectors element-wise. + +timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# +timesInt16X32# = timesInt16X32# + +-- | Multiply two vectors element-wise. + +timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# +timesInt32X16# = timesInt32X16# + +-- | Multiply two vectors element-wise. + +timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# +timesInt64X8# = timesInt64X8# + +-- | Multiply two vectors element-wise. + +timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# +timesWord8X16# = timesWord8X16# + +-- | Multiply two vectors element-wise. + +timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# +timesWord16X8# = timesWord16X8# + +-- | Multiply two vectors element-wise. + +timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# +timesWord32X4# = timesWord32X4# + +-- | Multiply two vectors element-wise. + +timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# +timesWord64X2# = timesWord64X2# + +-- | Multiply two vectors element-wise. + +timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# +timesWord8X32# = timesWord8X32# + +-- | Multiply two vectors element-wise. + +timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# +timesWord16X16# = timesWord16X16# + +-- | Multiply two vectors element-wise. + +timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# +timesWord32X8# = timesWord32X8# + +-- | Multiply two vectors element-wise. + +timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# +timesWord64X4# = timesWord64X4# + +-- | Multiply two vectors element-wise. + +timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# +timesWord8X64# = timesWord8X64# + +-- | Multiply two vectors element-wise. + +timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# +timesWord16X32# = timesWord16X32# + +-- | Multiply two vectors element-wise. + +timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# +timesWord32X16# = timesWord32X16# + +-- | Multiply two vectors element-wise. + +timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# +timesWord64X8# = timesWord64X8# + +-- | Multiply two vectors element-wise. + +timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# +timesFloatX4# = timesFloatX4# + +-- | Multiply two vectors element-wise. + +timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# +timesDoubleX2# = timesDoubleX2# + +-- | Multiply two vectors element-wise. + +timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# +timesFloatX8# = timesFloatX8# + +-- | Multiply two vectors element-wise. + +timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# +timesDoubleX4# = timesDoubleX4# + +-- | Multiply two vectors element-wise. + +timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# +timesFloatX16# = timesFloatX16# + +-- | Multiply two vectors element-wise. + +timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# +timesDoubleX8# = timesDoubleX8# + +-- | Divide two vectors element-wise. + +divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# +divideFloatX4# = divideFloatX4# + +-- | Divide two vectors element-wise. + +divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# +divideDoubleX2# = divideDoubleX2# + +-- | Divide two vectors element-wise. + +divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# +divideFloatX8# = divideFloatX8# + +-- | Divide two vectors element-wise. + +divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# +divideDoubleX4# = divideDoubleX4# + +-- | Divide two vectors element-wise. + +divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# +divideFloatX16# = divideFloatX16# + +-- | Divide two vectors element-wise. + +divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# +divideDoubleX8# = divideDoubleX8# + +-- | Rounds towards zero element-wise. + +quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# +quotInt8X16# = quotInt8X16# + +-- | Rounds towards zero element-wise. + +quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# +quotInt16X8# = quotInt16X8# + +-- | Rounds towards zero element-wise. + +quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# +quotInt32X4# = quotInt32X4# + +-- | Rounds towards zero element-wise. + +quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# +quotInt64X2# = quotInt64X2# + +-- | Rounds towards zero element-wise. + +quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# +quotInt8X32# = quotInt8X32# + +-- | Rounds towards zero element-wise. + +quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# +quotInt16X16# = quotInt16X16# + +-- | Rounds towards zero element-wise. + +quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# +quotInt32X8# = quotInt32X8# + +-- | Rounds towards zero element-wise. + +quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# +quotInt64X4# = quotInt64X4# + +-- | Rounds towards zero element-wise. + +quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# +quotInt8X64# = quotInt8X64# + +-- | Rounds towards zero element-wise. + +quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# +quotInt16X32# = quotInt16X32# + +-- | Rounds towards zero element-wise. + +quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# +quotInt32X16# = quotInt32X16# + +-- | Rounds towards zero element-wise. + +quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# +quotInt64X8# = quotInt64X8# + +-- | Rounds towards zero element-wise. + +quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# +quotWord8X16# = quotWord8X16# + +-- | Rounds towards zero element-wise. + +quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# +quotWord16X8# = quotWord16X8# + +-- | Rounds towards zero element-wise. + +quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# +quotWord32X4# = quotWord32X4# + +-- | Rounds towards zero element-wise. + +quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# +quotWord64X2# = quotWord64X2# + +-- | Rounds towards zero element-wise. + +quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# +quotWord8X32# = quotWord8X32# + +-- | Rounds towards zero element-wise. + +quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# +quotWord16X16# = quotWord16X16# + +-- | Rounds towards zero element-wise. + +quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# +quotWord32X8# = quotWord32X8# + +-- | Rounds towards zero element-wise. + +quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# +quotWord64X4# = quotWord64X4# + +-- | Rounds towards zero element-wise. + +quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# +quotWord8X64# = quotWord8X64# + +-- | Rounds towards zero element-wise. + +quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# +quotWord16X32# = quotWord16X32# + +-- | Rounds towards zero element-wise. + +quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# +quotWord32X16# = quotWord32X16# + +-- | Rounds towards zero element-wise. + +quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# +quotWord64X8# = quotWord64X8# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# +remInt8X16# = remInt8X16# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# +remInt16X8# = remInt16X8# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# +remInt32X4# = remInt32X4# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# +remInt64X2# = remInt64X2# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# +remInt8X32# = remInt8X32# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# +remInt16X16# = remInt16X16# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# +remInt32X8# = remInt32X8# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# +remInt64X4# = remInt64X4# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# +remInt8X64# = remInt8X64# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# +remInt16X32# = remInt16X32# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# +remInt32X16# = remInt32X16# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# +remInt64X8# = remInt64X8# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# +remWord8X16# = remWord8X16# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# +remWord16X8# = remWord16X8# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# +remWord32X4# = remWord32X4# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# +remWord64X2# = remWord64X2# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# +remWord8X32# = remWord8X32# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# +remWord16X16# = remWord16X16# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# +remWord32X8# = remWord32X8# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# +remWord64X4# = remWord64X4# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# +remWord8X64# = remWord8X64# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# +remWord16X32# = remWord16X32# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# +remWord32X16# = remWord32X16# + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# +remWord64X8# = remWord64X8# + +-- | Negate element-wise. + +negateInt8X16# :: Int8X16# -> Int8X16# +negateInt8X16# = negateInt8X16# + +-- | Negate element-wise. + +negateInt16X8# :: Int16X8# -> Int16X8# +negateInt16X8# = negateInt16X8# + +-- | Negate element-wise. + +negateInt32X4# :: Int32X4# -> Int32X4# +negateInt32X4# = negateInt32X4# + +-- | Negate element-wise. + +negateInt64X2# :: Int64X2# -> Int64X2# +negateInt64X2# = negateInt64X2# + +-- | Negate element-wise. + +negateInt8X32# :: Int8X32# -> Int8X32# +negateInt8X32# = negateInt8X32# + +-- | Negate element-wise. + +negateInt16X16# :: Int16X16# -> Int16X16# +negateInt16X16# = negateInt16X16# + +-- | Negate element-wise. + +negateInt32X8# :: Int32X8# -> Int32X8# +negateInt32X8# = negateInt32X8# + +-- | Negate element-wise. + +negateInt64X4# :: Int64X4# -> Int64X4# +negateInt64X4# = negateInt64X4# + +-- | Negate element-wise. + +negateInt8X64# :: Int8X64# -> Int8X64# +negateInt8X64# = negateInt8X64# + +-- | Negate element-wise. + +negateInt16X32# :: Int16X32# -> Int16X32# +negateInt16X32# = negateInt16X32# + +-- | Negate element-wise. + +negateInt32X16# :: Int32X16# -> Int32X16# +negateInt32X16# = negateInt32X16# + +-- | Negate element-wise. + +negateInt64X8# :: Int64X8# -> Int64X8# +negateInt64X8# = negateInt64X8# + +-- | Negate element-wise. + +negateFloatX4# :: FloatX4# -> FloatX4# +negateFloatX4# = negateFloatX4# + +-- | Negate element-wise. + +negateDoubleX2# :: DoubleX2# -> DoubleX2# +negateDoubleX2# = negateDoubleX2# + +-- | Negate element-wise. + +negateFloatX8# :: FloatX8# -> FloatX8# +negateFloatX8# = negateFloatX8# + +-- | Negate element-wise. + +negateDoubleX4# :: DoubleX4# -> DoubleX4# +negateDoubleX4# = negateDoubleX4# + +-- | Negate element-wise. + +negateFloatX16# :: FloatX16# -> FloatX16# +negateFloatX16# = negateFloatX16# + +-- | Negate element-wise. + +negateDoubleX8# :: DoubleX8# -> DoubleX8# +negateDoubleX8# = negateDoubleX8# + +-- | Read a vector from specified index of immutable array. + +indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16# +indexInt8X16Array# = indexInt8X16Array# + +-- | Read a vector from specified index of immutable array. + +indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8# +indexInt16X8Array# = indexInt16X8Array# + +-- | Read a vector from specified index of immutable array. + +indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4# +indexInt32X4Array# = indexInt32X4Array# + +-- | Read a vector from specified index of immutable array. + +indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2# +indexInt64X2Array# = indexInt64X2Array# + +-- | Read a vector from specified index of immutable array. + +indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32# +indexInt8X32Array# = indexInt8X32Array# + +-- | Read a vector from specified index of immutable array. + +indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16# +indexInt16X16Array# = indexInt16X16Array# + +-- | Read a vector from specified index of immutable array. + +indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8# +indexInt32X8Array# = indexInt32X8Array# + +-- | Read a vector from specified index of immutable array. + +indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4# +indexInt64X4Array# = indexInt64X4Array# + +-- | Read a vector from specified index of immutable array. + +indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64# +indexInt8X64Array# = indexInt8X64Array# + +-- | Read a vector from specified index of immutable array. + +indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32# +indexInt16X32Array# = indexInt16X32Array# + +-- | Read a vector from specified index of immutable array. + +indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16# +indexInt32X16Array# = indexInt32X16Array# + +-- | Read a vector from specified index of immutable array. + +indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8# +indexInt64X8Array# = indexInt64X8Array# + +-- | Read a vector from specified index of immutable array. + +indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16# +indexWord8X16Array# = indexWord8X16Array# + +-- | Read a vector from specified index of immutable array. + +indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8# +indexWord16X8Array# = indexWord16X8Array# + +-- | Read a vector from specified index of immutable array. + +indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4# +indexWord32X4Array# = indexWord32X4Array# + +-- | Read a vector from specified index of immutable array. + +indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2# +indexWord64X2Array# = indexWord64X2Array# + +-- | Read a vector from specified index of immutable array. + +indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32# +indexWord8X32Array# = indexWord8X32Array# + +-- | Read a vector from specified index of immutable array. + +indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16# +indexWord16X16Array# = indexWord16X16Array# + +-- | Read a vector from specified index of immutable array. + +indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8# +indexWord32X8Array# = indexWord32X8Array# + +-- | Read a vector from specified index of immutable array. + +indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4# +indexWord64X4Array# = indexWord64X4Array# + +-- | Read a vector from specified index of immutable array. + +indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64# +indexWord8X64Array# = indexWord8X64Array# + +-- | Read a vector from specified index of immutable array. + +indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32# +indexWord16X32Array# = indexWord16X32Array# + +-- | Read a vector from specified index of immutable array. + +indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16# +indexWord32X16Array# = indexWord32X16Array# + +-- | Read a vector from specified index of immutable array. + +indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8# +indexWord64X8Array# = indexWord64X8Array# + +-- | Read a vector from specified index of immutable array. + +indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4# +indexFloatX4Array# = indexFloatX4Array# + +-- | Read a vector from specified index of immutable array. + +indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2# +indexDoubleX2Array# = indexDoubleX2Array# + +-- | Read a vector from specified index of immutable array. + +indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8# +indexFloatX8Array# = indexFloatX8Array# + +-- | Read a vector from specified index of immutable array. + +indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4# +indexDoubleX4Array# = indexDoubleX4Array# + +-- | Read a vector from specified index of immutable array. + +indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16# +indexFloatX16Array# = indexFloatX16Array# + +-- | Read a vector from specified index of immutable array. + +indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8# +indexDoubleX8Array# = indexDoubleX8Array# + +-- | Read a vector from specified index of mutable array. + +readInt8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #) +readInt8X16Array# = readInt8X16Array# + +-- | Read a vector from specified index of mutable array. + +readInt16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #) +readInt16X8Array# = readInt16X8Array# + +-- | Read a vector from specified index of mutable array. + +readInt32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #) +readInt32X4Array# = readInt32X4Array# + +-- | Read a vector from specified index of mutable array. + +readInt64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #) +readInt64X2Array# = readInt64X2Array# + +-- | Read a vector from specified index of mutable array. + +readInt8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #) +readInt8X32Array# = readInt8X32Array# + +-- | Read a vector from specified index of mutable array. + +readInt16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #) +readInt16X16Array# = readInt16X16Array# + +-- | Read a vector from specified index of mutable array. + +readInt32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #) +readInt32X8Array# = readInt32X8Array# + +-- | Read a vector from specified index of mutable array. + +readInt64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #) +readInt64X4Array# = readInt64X4Array# + +-- | Read a vector from specified index of mutable array. + +readInt8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #) +readInt8X64Array# = readInt8X64Array# + +-- | Read a vector from specified index of mutable array. + +readInt16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #) +readInt16X32Array# = readInt16X32Array# + +-- | Read a vector from specified index of mutable array. + +readInt32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #) +readInt32X16Array# = readInt32X16Array# + +-- | Read a vector from specified index of mutable array. + +readInt64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #) +readInt64X8Array# = readInt64X8Array# + +-- | Read a vector from specified index of mutable array. + +readWord8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #) +readWord8X16Array# = readWord8X16Array# + +-- | Read a vector from specified index of mutable array. + +readWord16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #) +readWord16X8Array# = readWord16X8Array# + +-- | Read a vector from specified index of mutable array. + +readWord32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #) +readWord32X4Array# = readWord32X4Array# + +-- | Read a vector from specified index of mutable array. + +readWord64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #) +readWord64X2Array# = readWord64X2Array# + +-- | Read a vector from specified index of mutable array. + +readWord8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #) +readWord8X32Array# = readWord8X32Array# + +-- | Read a vector from specified index of mutable array. + +readWord16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #) +readWord16X16Array# = readWord16X16Array# + +-- | Read a vector from specified index of mutable array. + +readWord32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #) +readWord32X8Array# = readWord32X8Array# + +-- | Read a vector from specified index of mutable array. + +readWord64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #) +readWord64X4Array# = readWord64X4Array# + +-- | Read a vector from specified index of mutable array. + +readWord8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #) +readWord8X64Array# = readWord8X64Array# + +-- | Read a vector from specified index of mutable array. + +readWord16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #) +readWord16X32Array# = readWord16X32Array# + +-- | Read a vector from specified index of mutable array. + +readWord32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #) +readWord32X16Array# = readWord32X16Array# + +-- | Read a vector from specified index of mutable array. + +readWord64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #) +readWord64X8Array# = readWord64X8Array# + +-- | Read a vector from specified index of mutable array. + +readFloatX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #) +readFloatX4Array# = readFloatX4Array# + +-- | Read a vector from specified index of mutable array. + +readDoubleX2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #) +readDoubleX2Array# = readDoubleX2Array# + +-- | Read a vector from specified index of mutable array. + +readFloatX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #) +readFloatX8Array# = readFloatX8Array# + +-- | Read a vector from specified index of mutable array. + +readDoubleX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #) +readDoubleX4Array# = readDoubleX4Array# + +-- | Read a vector from specified index of mutable array. + +readFloatX16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #) +readFloatX16Array# = readFloatX16Array# + +-- | Read a vector from specified index of mutable array. + +readDoubleX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #) +readDoubleX8Array# = readDoubleX8Array# + +-- | Write a vector to specified index of mutable array. + +writeInt8X16Array# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s +writeInt8X16Array# = writeInt8X16Array# + +-- | Write a vector to specified index of mutable array. + +writeInt16X8Array# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s +writeInt16X8Array# = writeInt16X8Array# + +-- | Write a vector to specified index of mutable array. + +writeInt32X4Array# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s +writeInt32X4Array# = writeInt32X4Array# + +-- | Write a vector to specified index of mutable array. + +writeInt64X2Array# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s +writeInt64X2Array# = writeInt64X2Array# + +-- | Write a vector to specified index of mutable array. + +writeInt8X32Array# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s +writeInt8X32Array# = writeInt8X32Array# + +-- | Write a vector to specified index of mutable array. + +writeInt16X16Array# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s +writeInt16X16Array# = writeInt16X16Array# + +-- | Write a vector to specified index of mutable array. + +writeInt32X8Array# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s +writeInt32X8Array# = writeInt32X8Array# + +-- | Write a vector to specified index of mutable array. + +writeInt64X4Array# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s +writeInt64X4Array# = writeInt64X4Array# + +-- | Write a vector to specified index of mutable array. + +writeInt8X64Array# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s +writeInt8X64Array# = writeInt8X64Array# + +-- | Write a vector to specified index of mutable array. + +writeInt16X32Array# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s +writeInt16X32Array# = writeInt16X32Array# + +-- | Write a vector to specified index of mutable array. + +writeInt32X16Array# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s +writeInt32X16Array# = writeInt32X16Array# + +-- | Write a vector to specified index of mutable array. + +writeInt64X8Array# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s +writeInt64X8Array# = writeInt64X8Array# + +-- | Write a vector to specified index of mutable array. + +writeWord8X16Array# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s +writeWord8X16Array# = writeWord8X16Array# + +-- | Write a vector to specified index of mutable array. + +writeWord16X8Array# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s +writeWord16X8Array# = writeWord16X8Array# + +-- | Write a vector to specified index of mutable array. + +writeWord32X4Array# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s +writeWord32X4Array# = writeWord32X4Array# + +-- | Write a vector to specified index of mutable array. + +writeWord64X2Array# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s +writeWord64X2Array# = writeWord64X2Array# + +-- | Write a vector to specified index of mutable array. + +writeWord8X32Array# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s +writeWord8X32Array# = writeWord8X32Array# + +-- | Write a vector to specified index of mutable array. + +writeWord16X16Array# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s +writeWord16X16Array# = writeWord16X16Array# + +-- | Write a vector to specified index of mutable array. + +writeWord32X8Array# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s +writeWord32X8Array# = writeWord32X8Array# + +-- | Write a vector to specified index of mutable array. + +writeWord64X4Array# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s +writeWord64X4Array# = writeWord64X4Array# + +-- | Write a vector to specified index of mutable array. + +writeWord8X64Array# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s +writeWord8X64Array# = writeWord8X64Array# + +-- | Write a vector to specified index of mutable array. + +writeWord16X32Array# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s +writeWord16X32Array# = writeWord16X32Array# + +-- | Write a vector to specified index of mutable array. + +writeWord32X16Array# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s +writeWord32X16Array# = writeWord32X16Array# + +-- | Write a vector to specified index of mutable array. + +writeWord64X8Array# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s +writeWord64X8Array# = writeWord64X8Array# + +-- | Write a vector to specified index of mutable array. + +writeFloatX4Array# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s +writeFloatX4Array# = writeFloatX4Array# + +-- | Write a vector to specified index of mutable array. + +writeDoubleX2Array# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s +writeDoubleX2Array# = writeDoubleX2Array# + +-- | Write a vector to specified index of mutable array. + +writeFloatX8Array# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s +writeFloatX8Array# = writeFloatX8Array# + +-- | Write a vector to specified index of mutable array. + +writeDoubleX4Array# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s +writeDoubleX4Array# = writeDoubleX4Array# + +-- | Write a vector to specified index of mutable array. + +writeFloatX16Array# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s +writeFloatX16Array# = writeFloatX16Array# + +-- | Write a vector to specified index of mutable array. + +writeDoubleX8Array# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s +writeDoubleX8Array# = writeDoubleX8Array# + +-- | Reads vector; offset in bytes. + +indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# +indexInt8X16OffAddr# = indexInt8X16OffAddr# + +-- | Reads vector; offset in bytes. + +indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# +indexInt16X8OffAddr# = indexInt16X8OffAddr# + +-- | Reads vector; offset in bytes. + +indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# +indexInt32X4OffAddr# = indexInt32X4OffAddr# + +-- | Reads vector; offset in bytes. + +indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# +indexInt64X2OffAddr# = indexInt64X2OffAddr# + +-- | Reads vector; offset in bytes. + +indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# +indexInt8X32OffAddr# = indexInt8X32OffAddr# + +-- | Reads vector; offset in bytes. + +indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# +indexInt16X16OffAddr# = indexInt16X16OffAddr# + +-- | Reads vector; offset in bytes. + +indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# +indexInt32X8OffAddr# = indexInt32X8OffAddr# + +-- | Reads vector; offset in bytes. + +indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# +indexInt64X4OffAddr# = indexInt64X4OffAddr# + +-- | Reads vector; offset in bytes. + +indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# +indexInt8X64OffAddr# = indexInt8X64OffAddr# + +-- | Reads vector; offset in bytes. + +indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# +indexInt16X32OffAddr# = indexInt16X32OffAddr# + +-- | Reads vector; offset in bytes. + +indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# +indexInt32X16OffAddr# = indexInt32X16OffAddr# + +-- | Reads vector; offset in bytes. + +indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# +indexInt64X8OffAddr# = indexInt64X8OffAddr# + +-- | Reads vector; offset in bytes. + +indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# +indexWord8X16OffAddr# = indexWord8X16OffAddr# + +-- | Reads vector; offset in bytes. + +indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# +indexWord16X8OffAddr# = indexWord16X8OffAddr# + +-- | Reads vector; offset in bytes. + +indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# +indexWord32X4OffAddr# = indexWord32X4OffAddr# + +-- | Reads vector; offset in bytes. + +indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# +indexWord64X2OffAddr# = indexWord64X2OffAddr# + +-- | Reads vector; offset in bytes. + +indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# +indexWord8X32OffAddr# = indexWord8X32OffAddr# + +-- | Reads vector; offset in bytes. + +indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# +indexWord16X16OffAddr# = indexWord16X16OffAddr# + +-- | Reads vector; offset in bytes. + +indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# +indexWord32X8OffAddr# = indexWord32X8OffAddr# + +-- | Reads vector; offset in bytes. + +indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# +indexWord64X4OffAddr# = indexWord64X4OffAddr# + +-- | Reads vector; offset in bytes. + +indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# +indexWord8X64OffAddr# = indexWord8X64OffAddr# + +-- | Reads vector; offset in bytes. + +indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# +indexWord16X32OffAddr# = indexWord16X32OffAddr# + +-- | Reads vector; offset in bytes. + +indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# +indexWord32X16OffAddr# = indexWord32X16OffAddr# + +-- | Reads vector; offset in bytes. + +indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# +indexWord64X8OffAddr# = indexWord64X8OffAddr# + +-- | Reads vector; offset in bytes. + +indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# +indexFloatX4OffAddr# = indexFloatX4OffAddr# + +-- | Reads vector; offset in bytes. + +indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# +indexDoubleX2OffAddr# = indexDoubleX2OffAddr# + +-- | Reads vector; offset in bytes. + +indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# +indexFloatX8OffAddr# = indexFloatX8OffAddr# + +-- | Reads vector; offset in bytes. + +indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# +indexDoubleX4OffAddr# = indexDoubleX4OffAddr# + +-- | Reads vector; offset in bytes. + +indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# +indexFloatX16OffAddr# = indexFloatX16OffAddr# + +-- | Reads vector; offset in bytes. + +indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# +indexDoubleX8OffAddr# = indexDoubleX8OffAddr# + +-- | Reads vector; offset in bytes. + +readInt8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #) +readInt8X16OffAddr# = readInt8X16OffAddr# + +-- | Reads vector; offset in bytes. + +readInt16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #) +readInt16X8OffAddr# = readInt16X8OffAddr# + +-- | Reads vector; offset in bytes. + +readInt32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #) +readInt32X4OffAddr# = readInt32X4OffAddr# + +-- | Reads vector; offset in bytes. + +readInt64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #) +readInt64X2OffAddr# = readInt64X2OffAddr# + +-- | Reads vector; offset in bytes. + +readInt8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #) +readInt8X32OffAddr# = readInt8X32OffAddr# + +-- | Reads vector; offset in bytes. + +readInt16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #) +readInt16X16OffAddr# = readInt16X16OffAddr# + +-- | Reads vector; offset in bytes. + +readInt32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #) +readInt32X8OffAddr# = readInt32X8OffAddr# + +-- | Reads vector; offset in bytes. + +readInt64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #) +readInt64X4OffAddr# = readInt64X4OffAddr# + +-- | Reads vector; offset in bytes. + +readInt8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #) +readInt8X64OffAddr# = readInt8X64OffAddr# + +-- | Reads vector; offset in bytes. + +readInt16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #) +readInt16X32OffAddr# = readInt16X32OffAddr# + +-- | Reads vector; offset in bytes. + +readInt32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #) +readInt32X16OffAddr# = readInt32X16OffAddr# + +-- | Reads vector; offset in bytes. + +readInt64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #) +readInt64X8OffAddr# = readInt64X8OffAddr# + +-- | Reads vector; offset in bytes. + +readWord8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #) +readWord8X16OffAddr# = readWord8X16OffAddr# + +-- | Reads vector; offset in bytes. + +readWord16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #) +readWord16X8OffAddr# = readWord16X8OffAddr# + +-- | Reads vector; offset in bytes. + +readWord32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #) +readWord32X4OffAddr# = readWord32X4OffAddr# + +-- | Reads vector; offset in bytes. + +readWord64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #) +readWord64X2OffAddr# = readWord64X2OffAddr# + +-- | Reads vector; offset in bytes. + +readWord8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #) +readWord8X32OffAddr# = readWord8X32OffAddr# + +-- | Reads vector; offset in bytes. + +readWord16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #) +readWord16X16OffAddr# = readWord16X16OffAddr# + +-- | Reads vector; offset in bytes. + +readWord32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #) +readWord32X8OffAddr# = readWord32X8OffAddr# + +-- | Reads vector; offset in bytes. + +readWord64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #) +readWord64X4OffAddr# = readWord64X4OffAddr# + +-- | Reads vector; offset in bytes. + +readWord8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #) +readWord8X64OffAddr# = readWord8X64OffAddr# + +-- | Reads vector; offset in bytes. + +readWord16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #) +readWord16X32OffAddr# = readWord16X32OffAddr# + +-- | Reads vector; offset in bytes. + +readWord32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #) +readWord32X16OffAddr# = readWord32X16OffAddr# + +-- | Reads vector; offset in bytes. + +readWord64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #) +readWord64X8OffAddr# = readWord64X8OffAddr# + +-- | Reads vector; offset in bytes. + +readFloatX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #) +readFloatX4OffAddr# = readFloatX4OffAddr# + +-- | Reads vector; offset in bytes. + +readDoubleX2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #) +readDoubleX2OffAddr# = readDoubleX2OffAddr# + +-- | Reads vector; offset in bytes. + +readFloatX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #) +readFloatX8OffAddr# = readFloatX8OffAddr# + +-- | Reads vector; offset in bytes. + +readDoubleX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #) +readDoubleX4OffAddr# = readDoubleX4OffAddr# + +-- | Reads vector; offset in bytes. + +readFloatX16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #) +readFloatX16OffAddr# = readFloatX16OffAddr# + +-- | Reads vector; offset in bytes. + +readDoubleX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #) +readDoubleX8OffAddr# = readDoubleX8OffAddr# + +-- | Write vector; offset in bytes. + +writeInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s +writeInt8X16OffAddr# = writeInt8X16OffAddr# + +-- | Write vector; offset in bytes. + +writeInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s +writeInt16X8OffAddr# = writeInt16X8OffAddr# + +-- | Write vector; offset in bytes. + +writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s +writeInt32X4OffAddr# = writeInt32X4OffAddr# + +-- | Write vector; offset in bytes. + +writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s +writeInt64X2OffAddr# = writeInt64X2OffAddr# + +-- | Write vector; offset in bytes. + +writeInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s +writeInt8X32OffAddr# = writeInt8X32OffAddr# + +-- | Write vector; offset in bytes. + +writeInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s +writeInt16X16OffAddr# = writeInt16X16OffAddr# + +-- | Write vector; offset in bytes. + +writeInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s +writeInt32X8OffAddr# = writeInt32X8OffAddr# + +-- | Write vector; offset in bytes. + +writeInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s +writeInt64X4OffAddr# = writeInt64X4OffAddr# + +-- | Write vector; offset in bytes. + +writeInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s +writeInt8X64OffAddr# = writeInt8X64OffAddr# + +-- | Write vector; offset in bytes. + +writeInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s +writeInt16X32OffAddr# = writeInt16X32OffAddr# + +-- | Write vector; offset in bytes. + +writeInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s +writeInt32X16OffAddr# = writeInt32X16OffAddr# + +-- | Write vector; offset in bytes. + +writeInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s +writeInt64X8OffAddr# = writeInt64X8OffAddr# + +-- | Write vector; offset in bytes. + +writeWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s +writeWord8X16OffAddr# = writeWord8X16OffAddr# + +-- | Write vector; offset in bytes. + +writeWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s +writeWord16X8OffAddr# = writeWord16X8OffAddr# + +-- | Write vector; offset in bytes. + +writeWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s +writeWord32X4OffAddr# = writeWord32X4OffAddr# + +-- | Write vector; offset in bytes. + +writeWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s +writeWord64X2OffAddr# = writeWord64X2OffAddr# + +-- | Write vector; offset in bytes. + +writeWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s +writeWord8X32OffAddr# = writeWord8X32OffAddr# + +-- | Write vector; offset in bytes. + +writeWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s +writeWord16X16OffAddr# = writeWord16X16OffAddr# + +-- | Write vector; offset in bytes. + +writeWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s +writeWord32X8OffAddr# = writeWord32X8OffAddr# + +-- | Write vector; offset in bytes. + +writeWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s +writeWord64X4OffAddr# = writeWord64X4OffAddr# + +-- | Write vector; offset in bytes. + +writeWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s +writeWord8X64OffAddr# = writeWord8X64OffAddr# + +-- | Write vector; offset in bytes. + +writeWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s +writeWord16X32OffAddr# = writeWord16X32OffAddr# + +-- | Write vector; offset in bytes. + +writeWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s +writeWord32X16OffAddr# = writeWord32X16OffAddr# + +-- | Write vector; offset in bytes. + +writeWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s +writeWord64X8OffAddr# = writeWord64X8OffAddr# + +-- | Write vector; offset in bytes. + +writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s +writeFloatX4OffAddr# = writeFloatX4OffAddr# + +-- | Write vector; offset in bytes. + +writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s +writeDoubleX2OffAddr# = writeDoubleX2OffAddr# + +-- | Write vector; offset in bytes. + +writeFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s +writeFloatX8OffAddr# = writeFloatX8OffAddr# + +-- | Write vector; offset in bytes. + +writeDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s +writeDoubleX4OffAddr# = writeDoubleX4OffAddr# + +-- | Write vector; offset in bytes. + +writeFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s +writeFloatX16OffAddr# = writeFloatX16OffAddr# + +-- | Write vector; offset in bytes. + +writeDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s +writeDoubleX8OffAddr# = writeDoubleX8OffAddr# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16# +indexInt8ArrayAsInt8X16# = indexInt8ArrayAsInt8X16# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8# +indexInt16ArrayAsInt16X8# = indexInt16ArrayAsInt16X8# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4# +indexInt32ArrayAsInt32X4# = indexInt32ArrayAsInt32X4# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2# +indexInt64ArrayAsInt64X2# = indexInt64ArrayAsInt64X2# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32# +indexInt8ArrayAsInt8X32# = indexInt8ArrayAsInt8X32# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16# +indexInt16ArrayAsInt16X16# = indexInt16ArrayAsInt16X16# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8# +indexInt32ArrayAsInt32X8# = indexInt32ArrayAsInt32X8# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4# +indexInt64ArrayAsInt64X4# = indexInt64ArrayAsInt64X4# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64# +indexInt8ArrayAsInt8X64# = indexInt8ArrayAsInt8X64# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32# +indexInt16ArrayAsInt16X32# = indexInt16ArrayAsInt16X32# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16# +indexInt32ArrayAsInt32X16# = indexInt32ArrayAsInt32X16# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8# +indexInt64ArrayAsInt64X8# = indexInt64ArrayAsInt64X8# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16# +indexWord8ArrayAsWord8X16# = indexWord8ArrayAsWord8X16# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8# +indexWord16ArrayAsWord16X8# = indexWord16ArrayAsWord16X8# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4# +indexWord32ArrayAsWord32X4# = indexWord32ArrayAsWord32X4# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2# +indexWord64ArrayAsWord64X2# = indexWord64ArrayAsWord64X2# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32# +indexWord8ArrayAsWord8X32# = indexWord8ArrayAsWord8X32# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16# +indexWord16ArrayAsWord16X16# = indexWord16ArrayAsWord16X16# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8# +indexWord32ArrayAsWord32X8# = indexWord32ArrayAsWord32X8# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4# +indexWord64ArrayAsWord64X4# = indexWord64ArrayAsWord64X4# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64# +indexWord8ArrayAsWord8X64# = indexWord8ArrayAsWord8X64# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32# +indexWord16ArrayAsWord16X32# = indexWord16ArrayAsWord16X32# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16# +indexWord32ArrayAsWord32X16# = indexWord32ArrayAsWord32X16# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8# +indexWord64ArrayAsWord64X8# = indexWord64ArrayAsWord64X8# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4# +indexFloatArrayAsFloatX4# = indexFloatArrayAsFloatX4# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2# +indexDoubleArrayAsDoubleX2# = indexDoubleArrayAsDoubleX2# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8# +indexFloatArrayAsFloatX8# = indexFloatArrayAsFloatX8# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4# +indexDoubleArrayAsDoubleX4# = indexDoubleArrayAsDoubleX4# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16# +indexFloatArrayAsFloatX16# = indexFloatArrayAsFloatX16# + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8# +indexDoubleArrayAsDoubleX8# = indexDoubleArrayAsDoubleX8# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #) +readInt8ArrayAsInt8X16# = readInt8ArrayAsInt8X16# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #) +readInt16ArrayAsInt16X8# = readInt16ArrayAsInt16X8# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #) +readInt32ArrayAsInt32X4# = readInt32ArrayAsInt32X4# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #) +readInt64ArrayAsInt64X2# = readInt64ArrayAsInt64X2# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #) +readInt8ArrayAsInt8X32# = readInt8ArrayAsInt8X32# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #) +readInt16ArrayAsInt16X16# = readInt16ArrayAsInt16X16# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #) +readInt32ArrayAsInt32X8# = readInt32ArrayAsInt32X8# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #) +readInt64ArrayAsInt64X4# = readInt64ArrayAsInt64X4# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #) +readInt8ArrayAsInt8X64# = readInt8ArrayAsInt8X64# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #) +readInt16ArrayAsInt16X32# = readInt16ArrayAsInt16X32# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #) +readInt32ArrayAsInt32X16# = readInt32ArrayAsInt32X16# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #) +readInt64ArrayAsInt64X8# = readInt64ArrayAsInt64X8# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #) +readWord8ArrayAsWord8X16# = readWord8ArrayAsWord8X16# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #) +readWord16ArrayAsWord16X8# = readWord16ArrayAsWord16X8# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #) +readWord32ArrayAsWord32X4# = readWord32ArrayAsWord32X4# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #) +readWord64ArrayAsWord64X2# = readWord64ArrayAsWord64X2# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #) +readWord8ArrayAsWord8X32# = readWord8ArrayAsWord8X32# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #) +readWord16ArrayAsWord16X16# = readWord16ArrayAsWord16X16# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #) +readWord32ArrayAsWord32X8# = readWord32ArrayAsWord32X8# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #) +readWord64ArrayAsWord64X4# = readWord64ArrayAsWord64X4# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #) +readWord8ArrayAsWord8X64# = readWord8ArrayAsWord8X64# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #) +readWord16ArrayAsWord16X32# = readWord16ArrayAsWord16X32# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #) +readWord32ArrayAsWord32X16# = readWord32ArrayAsWord32X16# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #) +readWord64ArrayAsWord64X8# = readWord64ArrayAsWord64X8# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #) +readFloatArrayAsFloatX4# = readFloatArrayAsFloatX4# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #) +readDoubleArrayAsDoubleX2# = readDoubleArrayAsDoubleX2# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #) +readFloatArrayAsFloatX8# = readFloatArrayAsFloatX8# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #) +readDoubleArrayAsDoubleX4# = readDoubleArrayAsDoubleX4# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #) +readFloatArrayAsFloatX16# = readFloatArrayAsFloatX16# + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #) +readDoubleArrayAsDoubleX8# = readDoubleArrayAsDoubleX8# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s +writeInt8ArrayAsInt8X16# = writeInt8ArrayAsInt8X16# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s +writeInt16ArrayAsInt16X8# = writeInt16ArrayAsInt16X8# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s +writeInt32ArrayAsInt32X4# = writeInt32ArrayAsInt32X4# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s +writeInt64ArrayAsInt64X2# = writeInt64ArrayAsInt64X2# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s +writeInt8ArrayAsInt8X32# = writeInt8ArrayAsInt8X32# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s +writeInt16ArrayAsInt16X16# = writeInt16ArrayAsInt16X16# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s +writeInt32ArrayAsInt32X8# = writeInt32ArrayAsInt32X8# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s +writeInt64ArrayAsInt64X4# = writeInt64ArrayAsInt64X4# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s +writeInt8ArrayAsInt8X64# = writeInt8ArrayAsInt8X64# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s +writeInt16ArrayAsInt16X32# = writeInt16ArrayAsInt16X32# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s +writeInt32ArrayAsInt32X16# = writeInt32ArrayAsInt32X16# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s +writeInt64ArrayAsInt64X8# = writeInt64ArrayAsInt64X8# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s +writeWord8ArrayAsWord8X16# = writeWord8ArrayAsWord8X16# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s +writeWord16ArrayAsWord16X8# = writeWord16ArrayAsWord16X8# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s +writeWord32ArrayAsWord32X4# = writeWord32ArrayAsWord32X4# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s +writeWord64ArrayAsWord64X2# = writeWord64ArrayAsWord64X2# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s +writeWord8ArrayAsWord8X32# = writeWord8ArrayAsWord8X32# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s +writeWord16ArrayAsWord16X16# = writeWord16ArrayAsWord16X16# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s +writeWord32ArrayAsWord32X8# = writeWord32ArrayAsWord32X8# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s +writeWord64ArrayAsWord64X4# = writeWord64ArrayAsWord64X4# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s +writeWord8ArrayAsWord8X64# = writeWord8ArrayAsWord8X64# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s +writeWord16ArrayAsWord16X32# = writeWord16ArrayAsWord16X32# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s +writeWord32ArrayAsWord32X16# = writeWord32ArrayAsWord32X16# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s +writeWord64ArrayAsWord64X8# = writeWord64ArrayAsWord64X8# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s +writeFloatArrayAsFloatX4# = writeFloatArrayAsFloatX4# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s +writeDoubleArrayAsDoubleX2# = writeDoubleArrayAsDoubleX2# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s +writeFloatArrayAsFloatX8# = writeFloatArrayAsFloatX8# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s +writeDoubleArrayAsDoubleX4# = writeDoubleArrayAsDoubleX4# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s +writeFloatArrayAsFloatX16# = writeFloatArrayAsFloatX16# + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s +writeDoubleArrayAsDoubleX8# = writeDoubleArrayAsDoubleX8# + +-- | Reads vector; offset in scalar elements. + +indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# +indexInt8OffAddrAsInt8X16# = indexInt8OffAddrAsInt8X16# + +-- | Reads vector; offset in scalar elements. + +indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# +indexInt16OffAddrAsInt16X8# = indexInt16OffAddrAsInt16X8# + +-- | Reads vector; offset in scalar elements. + +indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# +indexInt32OffAddrAsInt32X4# = indexInt32OffAddrAsInt32X4# + +-- | Reads vector; offset in scalar elements. + +indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# +indexInt64OffAddrAsInt64X2# = indexInt64OffAddrAsInt64X2# + +-- | Reads vector; offset in scalar elements. + +indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# +indexInt8OffAddrAsInt8X32# = indexInt8OffAddrAsInt8X32# + +-- | Reads vector; offset in scalar elements. + +indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# +indexInt16OffAddrAsInt16X16# = indexInt16OffAddrAsInt16X16# + +-- | Reads vector; offset in scalar elements. + +indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# +indexInt32OffAddrAsInt32X8# = indexInt32OffAddrAsInt32X8# + +-- | Reads vector; offset in scalar elements. + +indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# +indexInt64OffAddrAsInt64X4# = indexInt64OffAddrAsInt64X4# + +-- | Reads vector; offset in scalar elements. + +indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# +indexInt8OffAddrAsInt8X64# = indexInt8OffAddrAsInt8X64# + +-- | Reads vector; offset in scalar elements. + +indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# +indexInt16OffAddrAsInt16X32# = indexInt16OffAddrAsInt16X32# + +-- | Reads vector; offset in scalar elements. + +indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# +indexInt32OffAddrAsInt32X16# = indexInt32OffAddrAsInt32X16# + +-- | Reads vector; offset in scalar elements. + +indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# +indexInt64OffAddrAsInt64X8# = indexInt64OffAddrAsInt64X8# + +-- | Reads vector; offset in scalar elements. + +indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# +indexWord8OffAddrAsWord8X16# = indexWord8OffAddrAsWord8X16# + +-- | Reads vector; offset in scalar elements. + +indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# +indexWord16OffAddrAsWord16X8# = indexWord16OffAddrAsWord16X8# + +-- | Reads vector; offset in scalar elements. + +indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# +indexWord32OffAddrAsWord32X4# = indexWord32OffAddrAsWord32X4# + +-- | Reads vector; offset in scalar elements. + +indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# +indexWord64OffAddrAsWord64X2# = indexWord64OffAddrAsWord64X2# + +-- | Reads vector; offset in scalar elements. + +indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# +indexWord8OffAddrAsWord8X32# = indexWord8OffAddrAsWord8X32# + +-- | Reads vector; offset in scalar elements. + +indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# +indexWord16OffAddrAsWord16X16# = indexWord16OffAddrAsWord16X16# + +-- | Reads vector; offset in scalar elements. + +indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# +indexWord32OffAddrAsWord32X8# = indexWord32OffAddrAsWord32X8# + +-- | Reads vector; offset in scalar elements. + +indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# +indexWord64OffAddrAsWord64X4# = indexWord64OffAddrAsWord64X4# + +-- | Reads vector; offset in scalar elements. + +indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# +indexWord8OffAddrAsWord8X64# = indexWord8OffAddrAsWord8X64# + +-- | Reads vector; offset in scalar elements. + +indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# +indexWord16OffAddrAsWord16X32# = indexWord16OffAddrAsWord16X32# + +-- | Reads vector; offset in scalar elements. + +indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# +indexWord32OffAddrAsWord32X16# = indexWord32OffAddrAsWord32X16# + +-- | Reads vector; offset in scalar elements. + +indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# +indexWord64OffAddrAsWord64X8# = indexWord64OffAddrAsWord64X8# + +-- | Reads vector; offset in scalar elements. + +indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# +indexFloatOffAddrAsFloatX4# = indexFloatOffAddrAsFloatX4# + +-- | Reads vector; offset in scalar elements. + +indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# +indexDoubleOffAddrAsDoubleX2# = indexDoubleOffAddrAsDoubleX2# + +-- | Reads vector; offset in scalar elements. + +indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# +indexFloatOffAddrAsFloatX8# = indexFloatOffAddrAsFloatX8# + +-- | Reads vector; offset in scalar elements. + +indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# +indexDoubleOffAddrAsDoubleX4# = indexDoubleOffAddrAsDoubleX4# + +-- | Reads vector; offset in scalar elements. + +indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# +indexFloatOffAddrAsFloatX16# = indexFloatOffAddrAsFloatX16# + +-- | Reads vector; offset in scalar elements. + +indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# +indexDoubleOffAddrAsDoubleX8# = indexDoubleOffAddrAsDoubleX8# + +-- | Reads vector; offset in scalar elements. + +readInt8OffAddrAsInt8X16# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #) +readInt8OffAddrAsInt8X16# = readInt8OffAddrAsInt8X16# + +-- | Reads vector; offset in scalar elements. + +readInt16OffAddrAsInt16X8# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #) +readInt16OffAddrAsInt16X8# = readInt16OffAddrAsInt16X8# + +-- | Reads vector; offset in scalar elements. + +readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #) +readInt32OffAddrAsInt32X4# = readInt32OffAddrAsInt32X4# + +-- | Reads vector; offset in scalar elements. + +readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #) +readInt64OffAddrAsInt64X2# = readInt64OffAddrAsInt64X2# + +-- | Reads vector; offset in scalar elements. + +readInt8OffAddrAsInt8X32# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #) +readInt8OffAddrAsInt8X32# = readInt8OffAddrAsInt8X32# + +-- | Reads vector; offset in scalar elements. + +readInt16OffAddrAsInt16X16# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #) +readInt16OffAddrAsInt16X16# = readInt16OffAddrAsInt16X16# + +-- | Reads vector; offset in scalar elements. + +readInt32OffAddrAsInt32X8# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #) +readInt32OffAddrAsInt32X8# = readInt32OffAddrAsInt32X8# + +-- | Reads vector; offset in scalar elements. + +readInt64OffAddrAsInt64X4# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #) +readInt64OffAddrAsInt64X4# = readInt64OffAddrAsInt64X4# + +-- | Reads vector; offset in scalar elements. + +readInt8OffAddrAsInt8X64# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #) +readInt8OffAddrAsInt8X64# = readInt8OffAddrAsInt8X64# + +-- | Reads vector; offset in scalar elements. + +readInt16OffAddrAsInt16X32# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #) +readInt16OffAddrAsInt16X32# = readInt16OffAddrAsInt16X32# + +-- | Reads vector; offset in scalar elements. + +readInt32OffAddrAsInt32X16# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #) +readInt32OffAddrAsInt32X16# = readInt32OffAddrAsInt32X16# + +-- | Reads vector; offset in scalar elements. + +readInt64OffAddrAsInt64X8# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #) +readInt64OffAddrAsInt64X8# = readInt64OffAddrAsInt64X8# + +-- | Reads vector; offset in scalar elements. + +readWord8OffAddrAsWord8X16# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #) +readWord8OffAddrAsWord8X16# = readWord8OffAddrAsWord8X16# + +-- | Reads vector; offset in scalar elements. + +readWord16OffAddrAsWord16X8# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #) +readWord16OffAddrAsWord16X8# = readWord16OffAddrAsWord16X8# + +-- | Reads vector; offset in scalar elements. + +readWord32OffAddrAsWord32X4# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #) +readWord32OffAddrAsWord32X4# = readWord32OffAddrAsWord32X4# + +-- | Reads vector; offset in scalar elements. + +readWord64OffAddrAsWord64X2# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #) +readWord64OffAddrAsWord64X2# = readWord64OffAddrAsWord64X2# + +-- | Reads vector; offset in scalar elements. + +readWord8OffAddrAsWord8X32# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #) +readWord8OffAddrAsWord8X32# = readWord8OffAddrAsWord8X32# + +-- | Reads vector; offset in scalar elements. + +readWord16OffAddrAsWord16X16# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #) +readWord16OffAddrAsWord16X16# = readWord16OffAddrAsWord16X16# + +-- | Reads vector; offset in scalar elements. + +readWord32OffAddrAsWord32X8# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #) +readWord32OffAddrAsWord32X8# = readWord32OffAddrAsWord32X8# + +-- | Reads vector; offset in scalar elements. + +readWord64OffAddrAsWord64X4# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #) +readWord64OffAddrAsWord64X4# = readWord64OffAddrAsWord64X4# + +-- | Reads vector; offset in scalar elements. + +readWord8OffAddrAsWord8X64# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #) +readWord8OffAddrAsWord8X64# = readWord8OffAddrAsWord8X64# + +-- | Reads vector; offset in scalar elements. + +readWord16OffAddrAsWord16X32# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #) +readWord16OffAddrAsWord16X32# = readWord16OffAddrAsWord16X32# + +-- | Reads vector; offset in scalar elements. + +readWord32OffAddrAsWord32X16# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #) +readWord32OffAddrAsWord32X16# = readWord32OffAddrAsWord32X16# + +-- | Reads vector; offset in scalar elements. + +readWord64OffAddrAsWord64X8# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #) +readWord64OffAddrAsWord64X8# = readWord64OffAddrAsWord64X8# + +-- | Reads vector; offset in scalar elements. + +readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #) +readFloatOffAddrAsFloatX4# = readFloatOffAddrAsFloatX4# + +-- | Reads vector; offset in scalar elements. + +readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #) +readDoubleOffAddrAsDoubleX2# = readDoubleOffAddrAsDoubleX2# + +-- | Reads vector; offset in scalar elements. + +readFloatOffAddrAsFloatX8# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #) +readFloatOffAddrAsFloatX8# = readFloatOffAddrAsFloatX8# + +-- | Reads vector; offset in scalar elements. + +readDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #) +readDoubleOffAddrAsDoubleX4# = readDoubleOffAddrAsDoubleX4# + +-- | Reads vector; offset in scalar elements. + +readFloatOffAddrAsFloatX16# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #) +readFloatOffAddrAsFloatX16# = readFloatOffAddrAsFloatX16# + +-- | Reads vector; offset in scalar elements. + +readDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #) +readDoubleOffAddrAsDoubleX8# = readDoubleOffAddrAsDoubleX8# + +-- | Write vector; offset in scalar elements. + +writeInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s +writeInt8OffAddrAsInt8X16# = writeInt8OffAddrAsInt8X16# + +-- | Write vector; offset in scalar elements. + +writeInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s +writeInt16OffAddrAsInt16X8# = writeInt16OffAddrAsInt16X8# + +-- | Write vector; offset in scalar elements. + +writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s +writeInt32OffAddrAsInt32X4# = writeInt32OffAddrAsInt32X4# + +-- | Write vector; offset in scalar elements. + +writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s +writeInt64OffAddrAsInt64X2# = writeInt64OffAddrAsInt64X2# + +-- | Write vector; offset in scalar elements. + +writeInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s +writeInt8OffAddrAsInt8X32# = writeInt8OffAddrAsInt8X32# + +-- | Write vector; offset in scalar elements. + +writeInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s +writeInt16OffAddrAsInt16X16# = writeInt16OffAddrAsInt16X16# + +-- | Write vector; offset in scalar elements. + +writeInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s +writeInt32OffAddrAsInt32X8# = writeInt32OffAddrAsInt32X8# + +-- | Write vector; offset in scalar elements. + +writeInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s +writeInt64OffAddrAsInt64X4# = writeInt64OffAddrAsInt64X4# + +-- | Write vector; offset in scalar elements. + +writeInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s +writeInt8OffAddrAsInt8X64# = writeInt8OffAddrAsInt8X64# + +-- | Write vector; offset in scalar elements. + +writeInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s +writeInt16OffAddrAsInt16X32# = writeInt16OffAddrAsInt16X32# + +-- | Write vector; offset in scalar elements. + +writeInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s +writeInt32OffAddrAsInt32X16# = writeInt32OffAddrAsInt32X16# + +-- | Write vector; offset in scalar elements. + +writeInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s +writeInt64OffAddrAsInt64X8# = writeInt64OffAddrAsInt64X8# + +-- | Write vector; offset in scalar elements. + +writeWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s +writeWord8OffAddrAsWord8X16# = writeWord8OffAddrAsWord8X16# + +-- | Write vector; offset in scalar elements. + +writeWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s +writeWord16OffAddrAsWord16X8# = writeWord16OffAddrAsWord16X8# + +-- | Write vector; offset in scalar elements. + +writeWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s +writeWord32OffAddrAsWord32X4# = writeWord32OffAddrAsWord32X4# + +-- | Write vector; offset in scalar elements. + +writeWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s +writeWord64OffAddrAsWord64X2# = writeWord64OffAddrAsWord64X2# + +-- | Write vector; offset in scalar elements. + +writeWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s +writeWord8OffAddrAsWord8X32# = writeWord8OffAddrAsWord8X32# + +-- | Write vector; offset in scalar elements. + +writeWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s +writeWord16OffAddrAsWord16X16# = writeWord16OffAddrAsWord16X16# + +-- | Write vector; offset in scalar elements. + +writeWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s +writeWord32OffAddrAsWord32X8# = writeWord32OffAddrAsWord32X8# + +-- | Write vector; offset in scalar elements. + +writeWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s +writeWord64OffAddrAsWord64X4# = writeWord64OffAddrAsWord64X4# + +-- | Write vector; offset in scalar elements. + +writeWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s +writeWord8OffAddrAsWord8X64# = writeWord8OffAddrAsWord8X64# + +-- | Write vector; offset in scalar elements. + +writeWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s +writeWord16OffAddrAsWord16X32# = writeWord16OffAddrAsWord16X32# + +-- | Write vector; offset in scalar elements. + +writeWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s +writeWord32OffAddrAsWord32X16# = writeWord32OffAddrAsWord32X16# + +-- | Write vector; offset in scalar elements. + +writeWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s +writeWord64OffAddrAsWord64X8# = writeWord64OffAddrAsWord64X8# + +-- | Write vector; offset in scalar elements. + +writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s +writeFloatOffAddrAsFloatX4# = writeFloatOffAddrAsFloatX4# + +-- | Write vector; offset in scalar elements. + +writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s +writeDoubleOffAddrAsDoubleX2# = writeDoubleOffAddrAsDoubleX2# + +-- | Write vector; offset in scalar elements. + +writeFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s +writeFloatOffAddrAsFloatX8# = writeFloatOffAddrAsFloatX8# + +-- | Write vector; offset in scalar elements. + +writeDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s +writeDoubleOffAddrAsDoubleX4# = writeDoubleOffAddrAsDoubleX4# + +-- | Write vector; offset in scalar elements. + +writeFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s +writeFloatOffAddrAsFloatX16# = writeFloatOffAddrAsFloatX16# + +-- | Write vector; offset in scalar elements. + +writeDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s +writeDoubleOffAddrAsDoubleX8# = writeDoubleOffAddrAsDoubleX8# + +prefetchByteArray3# :: ByteArray# -> Int# -> State# s -> State# s +prefetchByteArray3# = prefetchByteArray3# + +prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray3# = prefetchMutableByteArray3# + +prefetchAddr3# :: Addr# -> Int# -> State# s -> State# s +prefetchAddr3# = prefetchAddr3# + +prefetchValue3# :: a -> State# s -> State# s +prefetchValue3# = prefetchValue3# + +prefetchByteArray2# :: ByteArray# -> Int# -> State# s -> State# s +prefetchByteArray2# = prefetchByteArray2# + +prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray2# = prefetchMutableByteArray2# + +prefetchAddr2# :: Addr# -> Int# -> State# s -> State# s +prefetchAddr2# = prefetchAddr2# + +prefetchValue2# :: a -> State# s -> State# s +prefetchValue2# = prefetchValue2# + +prefetchByteArray1# :: ByteArray# -> Int# -> State# s -> State# s +prefetchByteArray1# = prefetchByteArray1# + +prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray1# = prefetchMutableByteArray1# + +prefetchAddr1# :: Addr# -> Int# -> State# s -> State# s +prefetchAddr1# = prefetchAddr1# + +prefetchValue1# :: a -> State# s -> State# s +prefetchValue1# = prefetchValue1# + +prefetchByteArray0# :: ByteArray# -> Int# -> State# s -> State# s +prefetchByteArray0# = prefetchByteArray0# + +prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray0# = prefetchMutableByteArray0# + +prefetchAddr0# :: Addr# -> Int# -> State# s -> State# s +prefetchAddr0# = prefetchAddr0# + +prefetchValue0# :: a -> State# s -> State# s +prefetchValue0# = prefetchValue0# diff --git a/GHC/PrimopWrappers.hs b/GHC/PrimopWrappers.hs --- a/GHC/PrimopWrappers.hs +++ b/GHC/PrimopWrappers.hs @@ -114,6 +114,9 @@ {-# NOINLINE plusWord# #-} plusWord# :: Word# -> Word# -> Word# plusWord# a1 a2 = (GHC.Prim.plusWord#) a1 a2 +{-# NOINLINE subWordC# #-} +subWordC# :: Word# -> Word# -> (# Word#,Int# #) +subWordC# a1 a2 = (GHC.Prim.subWordC#) a1 a2 {-# NOINLINE plusWord2# #-} plusWord2# :: Word# -> Word# -> (# Word#,Word# #) plusWord2# a1 a2 = (GHC.Prim.plusWord2#) a1 a2 @@ -543,6 +546,9 @@ {-# NOINLINE sizeofMutableByteArray# #-} sizeofMutableByteArray# :: MutableByteArray# s -> Int# sizeofMutableByteArray# a1 = (GHC.Prim.sizeofMutableByteArray#) a1 +{-# NOINLINE getSizeofMutableByteArray# #-} +getSizeofMutableByteArray# :: MutableByteArray# s -> State# s -> (# State# s,Int# #) +getSizeofMutableByteArray# a1 a2 = (GHC.Prim.getSizeofMutableByteArray#) a1 a2 {-# NOINLINE indexCharArray# #-} indexCharArray# :: ByteArray# -> Int# -> Char# indexCharArray# a1 a2 = (GHC.Prim.indexCharArray#) a1 a2 @@ -982,7 +988,7 @@ catch# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) catch# a1 a2 a3 = (GHC.Prim.catch#) a1 a2 a3 {-# NOINLINE raise# #-} -raise# :: a -> b +raise# :: b -> o raise# a1 = (GHC.Prim.raise#) a1 {-# NOINLINE raiseIO# #-} raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld),b #) @@ -1012,7 +1018,7 @@ catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) catchSTM# a1 a2 a3 = (GHC.Prim.catchSTM#) a1 a2 a3 {-# NOINLINE check# #-} -check# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),() #) +check# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> State# (RealWorld) check# a1 a2 = (GHC.Prim.check#) a1 a2 {-# NOINLINE newTVar# #-} newTVar# :: a -> State# s -> (# State# s,TVar# s a #) @@ -1093,7 +1099,7 @@ threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #) threadStatus# a1 a2 = (GHC.Prim.threadStatus#) a1 a2 {-# NOINLINE mkWeak# #-} -mkWeak# :: o -> b -> c -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #) +mkWeak# :: o -> b -> (State# (RealWorld) -> (# State# (RealWorld),c #)) -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #) mkWeak# a1 a2 a3 a4 = (GHC.Prim.mkWeak#) a1 a2 a3 a4 {-# NOINLINE mkWeakNoFinalizer# #-} mkWeakNoFinalizer# :: o -> b -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #) @@ -1105,7 +1111,7 @@ deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,a #) deRefWeak# a1 a2 = (GHC.Prim.deRefWeak#) a1 a2 {-# NOINLINE finalizeWeak# #-} -finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),() #) #) +finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),b #) #) finalizeWeak# a1 a2 = (GHC.Prim.finalizeWeak#) a1 a2 {-# NOINLINE touch# #-} touch# :: o -> State# (RealWorld) -> State# (RealWorld) @@ -1131,9 +1137,15 @@ {-# NOINLINE reallyUnsafePtrEquality# #-} reallyUnsafePtrEquality# :: a -> a -> Int# reallyUnsafePtrEquality# a1 a2 = (GHC.Prim.reallyUnsafePtrEquality#) a1 a2 +{-# NOINLINE par# #-} +par# :: a -> Int# +par# a1 = (GHC.Prim.par#) a1 {-# NOINLINE spark# #-} spark# :: a -> State# s -> (# State# s,a #) spark# a1 a2 = (GHC.Prim.spark#) a1 a2 +{-# NOINLINE seq# #-} +seq# :: a -> State# s -> (# State# s,a #) +seq# a1 a2 = (GHC.Prim.seq#) a1 a2 {-# NOINLINE getSpark# #-} getSpark# :: State# s -> (# State# s,Int#,a #) getSpark# a1 = (GHC.Prim.getSpark#) a1 @@ -1164,6 +1176,9 @@ {-# NOINLINE getCurrentCCS# #-} getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #) getCurrentCCS# a1 a2 = (GHC.Prim.getCurrentCCS#) a1 a2 +{-# NOINLINE clearCCS# #-} +clearCCS# :: (State# s -> (# State# s,a #)) -> State# s -> (# State# s,a #) +clearCCS# a1 a2 = (GHC.Prim.clearCCS#) a1 a2 {-# NOINLINE traceEvent# #-} traceEvent# :: Addr# -> State# s -> State# s traceEvent# a1 a2 = (GHC.Prim.traceEvent#) a1 a2 diff --git a/GHC/Tuple.hs b/GHC/Tuple.hs --- a/GHC/Tuple.hs +++ b/GHC/Tuple.hs @@ -16,6 +16,9 @@ module GHC.Tuple where +import GHC.CString () -- Make sure we do it first, so that the + -- implicit Typeable stuff can see GHC.Types.TyCon + -- and unpackCString# etc default () -- Double and Integer aren't available yet @@ -23,113 +26,146 @@ -- constructor @()@. data () = () -data (,) a b = (,) a b -data (,,) a b c = (,,) a b c -data (,,,) a b c d = (,,,) a b c d -data (,,,,) a b c d e = (,,,,) a b c d e -data (,,,,,) a b c d e f = (,,,,,) a b c d e f -data (,,,,,,) a b c d e f g = (,,,,,,) a b c d e f g -data (,,,,,,,) a b c d e f g h = (,,,,,,,) a b c d e f g h -data (,,,,,,,,) a b c d e f g h i = (,,,,,,,,) a b c d e f g h i -data (,,,,,,,,,) a b c d e f g h i j = (,,,,,,,,,) a b c d e f g h i j -data (,,,,,,,,,,) a b c d e f g h i j k = (,,,,,,,,,,) a b c d e f g h i j k -data (,,,,,,,,,,,) a b c d e f g h i j k l = (,,,,,,,,,,,) a b c d e f g h i j k l -data (,,,,,,,,,,,,) a b c d e f g h i j k l m = (,,,,,,,,,,,,) a b c d e f g h i j k l m -data (,,,,,,,,,,,,,) a b c d e f g h i j k l m n = (,,,,,,,,,,,,,) a b c d e f g h i j k l m n -data (,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o = (,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o -data (,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p = (,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p -data (,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q - = (,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q -data (,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r - = (,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r -data (,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s - = (,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s -data (,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t - = (,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t -data (,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u - = (,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u -data (,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v - = (,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v -data (,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w - = (,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w -data (,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x - = (,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x -data (,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y - = (,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y -data (,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z - = (,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z -data (,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ -data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ - = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ +-- The desugarer uses 1-tuples, +-- but "()" is already used up for 0-tuples +-- See Note [One-tuples] in TysWiredIn +data Unit a = Unit a + +data (a,b) = (a,b) +data (a,b,c) = (a,b,c) +data (a,b,c,d) = (a,b,c,d) +data (a,b,c,d,e) = (a,b,c,d,e) +data (a,b,c,d,e,f) = (a,b,c,d,e,f) +data (a,b,c,d,e,f,g) = (a,b,c,d,e,f,g) +data (a,b,c,d,e,f,g,h) = (a,b,c,d,e,f,g,h) +data (a,b,c,d,e,f,g,h,i) = (a,b,c,d,e,f,g,h,i) +data (a,b,c,d,e,f,g,h,i,j) = (a,b,c,d,e,f,g,h,i,j) +data (a,b,c,d,e,f,g,h,i,j,k) = (a,b,c,d,e,f,g,h,i,j,k) +data (a,b,c,d,e,f,g,h,i,j,k,l) = (a,b,c,d,e,f,g,h,i,j,k,l) +data (a,b,c,d,e,f,g,h,i,j,k,l,m) = (a,b,c,d,e,f,g,h,i,j,k,l,m) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z) + +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2) +data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2) + = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1, + r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2) {- Manuel says: Including one more declaration gives a segmentation fault. data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ diff --git a/GHC/Types.hs b/GHC/Types.hs --- a/GHC/Types.hs +++ b/GHC/Types.hs @@ -1,5 +1,5 @@ {-# LANGUAGE MagicHash, NoImplicitPrelude, TypeFamilies, UnboxedTuples, - RoleAnnotations #-} + MultiParamTypeClasses, RoleAnnotations, CPP, TypeOperators #-} ----------------------------------------------------------------------------- -- | -- Module : GHC.Types @@ -17,23 +17,94 @@ ----------------------------------------------------------------------------- module GHC.Types ( + -- Data types that are built-in syntax + -- They are defined here, but not explicitly exported + -- + -- Lists: []( [], (:) ) + -- Type equality: (~)( Eq# ) + Bool(..), Char(..), Int(..), Word(..), Float(..), Double(..), Ordering(..), IO(..), isTrue#, SPEC(..), - Coercible, + Nat, Symbol, + type (~~), Coercible, + TYPE, RuntimeRep(..), Type, type (*), type (★), Constraint, + -- The historical type * should ideally be written as + -- `type *`, without the parentheses. But that's a true + -- pain to parse, and for little gain. + VecCount(..), VecElem(..), + + -- * Runtime type representation + Module(..), TrName(..), TyCon(..) ) where import GHC.Prim - infixr 5 : +-- Take note: All types defined here must have associated type representations +-- defined in Data.Typeable.Internal. +-- See Note [Representation of types defined in GHC.Types] below. + +{- ********************************************************************* +* * + Kinds +* * +********************************************************************* -} + +-- | The kind of constraints, like @Show a@ +data Constraint + +-- | The kind of types with values. For example @Int :: Type@. +type Type = TYPE 'PtrRepLifted + +-- | A backward-compatible (pre-GHC 8.0) synonym for 'Type' +type * = TYPE 'PtrRepLifted + +-- | A unicode backward-compatible (pre-GHC 8.0) synonym for 'Type' +type ★ = TYPE 'PtrRepLifted + +{- ********************************************************************* +* * + Nat and Symbol +* * +********************************************************************* -} + +-- | (Kind) This is the kind of type-level natural numbers. +data Nat + +-- | (Kind) This is the kind of type-level symbols. +-- Declared here because class IP needs it +data Symbol + +{- ********************************************************************* +* * + Lists + + NB: lists are built-in syntax, and hence not explicitly exported +* * +********************************************************************* -} + data [] a = [] | a : [a] -data {-# CTYPE "HsBool" #-} Bool = False | True +{- ********************************************************************* +* * + Ordering +* * +********************************************************************* -} + +data Ordering = LT | EQ | GT + + +{- ********************************************************************* +* * + Int, Char, Word, Float, Double +* * +********************************************************************* -} + {- | The character type 'Char' is an enumeration whose values represent Unicode (or equivalently ISO\/IEC 10646) characters (see for details). This set extends the ISO 8859-1 @@ -65,8 +136,13 @@ -- to the IEEE double-precision type. data {-# CTYPE "HsDouble" #-} Double = D# Double# -data Ordering = LT | EQ | GT +{- ********************************************************************* +* * + IO +* * +********************************************************************* -} + {- | A value of type @'IO' a@ is a computation which, when performed, does some I\/O before returning a value of type @a@. @@ -82,13 +158,22 @@ -} newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #)) type role IO representational -{- -The above role annotation is redundant but is included because this role -is significant in the normalisation of FFI types. Specifically, if this -role were to become nominal (which would be very strange, indeed!), changes -elsewhere in GHC would be necessary. See [FFI type roles] in TcForeign. --} +{- The 'type role' role annotation for IO is redundant but is included +because this role is significant in the normalisation of FFI +types. Specifically, if this role were to become nominal (which would +be very strange, indeed!), changes elsewhere in GHC would be +necessary. See [FFI type roles] in TcForeign. -} + + +{- ********************************************************************* +* * + (~) and Coercible + + NB: (~) is built-in syntax, and hence not explicitly exported +* * +********************************************************************* -} + {- Note [Kind-changing of (~) and Coercible] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -106,14 +191,17 @@ -} --- | A data constructor used to box up all unlifted equalities --- --- The type constructor is special in that GHC pretends that it --- has kind (? -> ? -> Fact) rather than (* -> * -> *) -data (~) a b = Eq# ((~#) a b) - +-- | Lifted, heterogeneous equality. By lifted, we mean that it +-- can be bogus (deferred type error). By heterogeneous, the two +-- types @a@ and @b@ 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. +class a ~~ b + -- See also Note [The equality types story] in TysPrim --- | This two-parameter class has instances for types @a@ and @b@ if +-- | @Coercible@ is a two-parameter class that has instances for types @a@ and @b@ 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 of @Coercible@ @@ -160,75 +248,84 @@ -- by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich. -- -- @since 4.7.0.0 -data Coercible a b = MkCoercible ((~#) a b) --- It's really ~R# (representational equality), not ~#, --- but * we don't yet have syntax for ~R#, --- * the compiled code is the same either way --- * TysWiredIn has the truthful types --- Also see Note [Kind-changing of (~) and Coercible] +class Coercible a b + -- See also Note [The equality types story] in TysPrim --- | Alias for 'tagToEnum#'. Returns True if its parameter is 1# and False --- if it is 0#. +{- ********************************************************************* +* * + Bool, and isTrue# +* * +********************************************************************* -} +data {-# CTYPE "HsBool" #-} Bool = False | True + {-# INLINE isTrue# #-} +-- | Alias for 'tagToEnum#'. Returns True if its parameter is 1# and False +-- if it is 0#. isTrue# :: Int# -> Bool -- See Note [Optimizing isTrue#] isTrue# x = tagToEnum# x --- Note [Optimizing isTrue#] --- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --- --- Current definition of isTrue# is a temporary workaround. We would like to --- have functions isTrue# and isFalse# defined like this: --- --- isTrue# :: Int# -> Bool --- isTrue# 1# = True --- isTrue# _ = False --- --- isFalse# :: Int# -> Bool --- isFalse# 0# = True --- isFalse# _ = False --- --- These functions would allow us to safely check if a tag can represent True --- or False. Using isTrue# and isFalse# as defined above will not introduce --- additional case into the code. When we scrutinize return value of isTrue# --- or isFalse#, either explicitly in a case expression or implicitly in a guard, --- the result will always be a single case expression (given that optimizations --- are turned on). This results from case-of-case transformation. Consider this --- code (this is both valid Haskell and Core): --- --- case isTrue# (a ># b) of --- True -> e1 --- False -> e2 --- --- Inlining isTrue# gives: --- --- case (case (a ># b) of { 1# -> True; _ -> False } ) of --- True -> e1 --- False -> e2 --- --- Case-of-case transforms that to: --- --- case (a ># b) of --- 1# -> case True of --- True -> e1 --- False -> e2 --- _ -> case False of --- True -> e1 --- False -> e2 --- --- Which is then simplified by case-of-known-constructor: --- --- case (a ># b) of --- 1# -> e1 --- _ -> e2 --- --- While we get good Core here, the code generator will generate very bad Cmm --- if e1 or e2 do allocation. It will push heap checks into case alternatives --- which results in about 2.5% increase in code size. Until this is improved we --- just make isTrue# an alias to tagToEnum#. This is a temporary solution (if --- you're reading this in 2023 then things went wrong). See #8326. --- +{- Note [Optimizing isTrue#] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Current definition of isTrue# is a temporary workaround. We would like to +have functions isTrue# and isFalse# defined like this: + isTrue# :: Int# -> Bool + isTrue# 1# = True + isTrue# _ = False + + isFalse# :: Int# -> Bool + isFalse# 0# = True + isFalse# _ = False + +These functions would allow us to safely check if a tag can represent True +or False. Using isTrue# and isFalse# as defined above will not introduce +additional case into the code. When we scrutinize return value of isTrue# +or isFalse#, either explicitly in a case expression or implicitly in a guard, +the result will always be a single case expression (given that optimizations +are turned on). This results from case-of-case transformation. Consider this +code (this is both valid Haskell and Core): + +case isTrue# (a ># b) of + True -> e1 + False -> e2 + +Inlining isTrue# gives: + +case (case (a ># b) of { 1# -> True; _ -> False } ) of + True -> e1 + False -> e2 + +Case-of-case transforms that to: + +case (a ># b) of + 1# -> case True of + True -> e1 + False -> e2 + _ -> case False of + True -> e1 + False -> e2 + +Which is then simplified by case-of-known-constructor: + +case (a ># b) of + 1# -> e1 + _ -> e2 + +While we get good Core here, the code generator will generate very bad Cmm +if e1 or e2 do allocation. It will push heap checks into case alternatives +which results in about 2.5% increase in code size. Until this is improved we +just make isTrue# an alias to tagToEnum#. This is a temporary solution (if +you're reading this in 2023 then things went wrong). See #8326. +-} + + +{- ********************************************************************* +* * + SPEC +* * +********************************************************************* -} + -- | 'SPEC' is used by GHC in the @SpecConstr@ pass in order to inform -- the compiler when to be particularly aggressive. In particular, it -- tells GHC to specialize regardless of size or the number of @@ -237,3 +334,102 @@ -- Libraries can specify this by using 'SPEC' data type to inform which -- loops should be aggressively specialized. data SPEC = SPEC | SPEC2 + + +{- ********************************************************************* +* * + RuntimeRep +* * +********************************************************************* -} + + +-- | 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 that 'TYPE' is parameterised by 'RuntimeRep'; 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). +data RuntimeRep = VecRep VecCount VecElem -- ^ a SIMD vector type + | PtrRepLifted -- ^ lifted; represented by a pointer + | PtrRepUnlifted -- ^ unlifted; represented by a pointer + | VoidRep -- ^ erased entirely + | 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, but /not/ to a Haskell value + | FloatRep -- ^ a 32-bit floating point number + | DoubleRep -- ^ a 64-bit floating point number + | UnboxedTupleRep -- ^ An unboxed tuple; this doesn't specify a concrete rep + +-- See also Note [Wiring in RuntimeRep] in TysWiredIn + +-- | Length of a SIMD vector type +data VecCount = Vec2 + | Vec4 + | Vec8 + | Vec16 + | Vec32 + | Vec64 + +-- | Element of a SIMD vector type +data VecElem = Int8ElemRep + | Int16ElemRep + | Int32ElemRep + | Int64ElemRep + | Word8ElemRep + | Word16ElemRep + | Word32ElemRep + | Word64ElemRep + | FloatElemRep + | DoubleElemRep + +{- ********************************************************************* +* * + Runtime representation of TyCon +* * +********************************************************************* -} + +{- Note [Runtime representation of modules and tycons] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +We generate a binding for M.$modName and M.$tcT for every module M and +data type T. Things to think about + + - We want them to be economical on space; ideally pure data with no thunks. + + - We do this for every module (except this module GHC.Types), so we can't + depend on anything else (eg string unpacking code) + +That's why we have these terribly low-level repesentations. The TrName +type lets us use the TrNameS constructor when allocating static data; +but we also need TrNameD for the case where we are deserialising a TyCon +or Module (for example when deserialising a TypeRep), in which case we +can't conveniently come up with an Addr#. +-} + +#include "MachDeps.h" + +data Module = Module + TrName -- Package name + TrName -- Module name + +data TrName + = TrNameS Addr# -- Static + | TrNameD [Char] -- Dynamic + +#if WORD_SIZE_IN_BITS < 64 +data TyCon = TyCon + Word64# Word64# -- Fingerprint + Module -- Module in which this is defined + TrName -- Type constructor name +#else +data TyCon = TyCon + Word# Word# + Module + TrName +#endif diff --git a/Setup.hs b/Setup.hs --- a/Setup.hs +++ b/Setup.hs @@ -1,2 +1,6 @@ +module Main (main) where + import Distribution.Simple + +main :: IO () main = defaultMain diff --git a/cbits/atomic.c b/cbits/atomic.c --- a/cbits/atomic.c +++ b/cbits/atomic.c @@ -11,97 +11,97 @@ // FetchAddByteArrayOp_Int -extern StgWord hs_atomic_add8(volatile StgWord8 *x, StgWord val); +extern StgWord hs_atomic_add8(StgWord x, StgWord val); StgWord -hs_atomic_add8(volatile StgWord8 *x, StgWord val) +hs_atomic_add8(StgWord x, StgWord val) { - return __sync_fetch_and_add(x, (StgWord8) val); + return __sync_fetch_and_add((volatile StgWord8 *) x, (StgWord8) val); } -extern StgWord hs_atomic_add16(volatile StgWord16 *x, StgWord val); +extern StgWord hs_atomic_add16(StgWord x, StgWord val); StgWord -hs_atomic_add16(volatile StgWord16 *x, StgWord val) +hs_atomic_add16(StgWord x, StgWord val) { - return __sync_fetch_and_add(x, (StgWord16) val); + return __sync_fetch_and_add((volatile StgWord16 *) x, (StgWord16) val); } -extern StgWord hs_atomic_add32(volatile StgWord32 *x, StgWord val); +extern StgWord hs_atomic_add32(StgWord x, StgWord val); StgWord -hs_atomic_add32(volatile StgWord32 *x, StgWord val) +hs_atomic_add32(StgWord x, StgWord val) { - return __sync_fetch_and_add(x, (StgWord32) val); + return __sync_fetch_and_add((volatile StgWord32 *) x, (StgWord32) val); } #if WORD_SIZE_IN_BITS == 64 -extern StgWord64 hs_atomic_add64(volatile StgWord64 *x, StgWord64 val); +extern StgWord64 hs_atomic_add64(StgWord x, StgWord64 val); StgWord64 -hs_atomic_add64(volatile StgWord64 *x, StgWord64 val) +hs_atomic_add64(StgWord x, StgWord64 val) { - return __sync_fetch_and_add(x, val); + return __sync_fetch_and_add((volatile StgWord64 *) x, val); } #endif // FetchSubByteArrayOp_Int -extern StgWord hs_atomic_sub8(volatile StgWord8 *x, StgWord val); +extern StgWord hs_atomic_sub8(StgWord x, StgWord val); StgWord -hs_atomic_sub8(volatile StgWord8 *x, StgWord val) +hs_atomic_sub8(StgWord x, StgWord val) { - return __sync_fetch_and_sub(x, (StgWord8) val); + return __sync_fetch_and_sub((volatile StgWord8 *) x, (StgWord8) val); } -extern StgWord hs_atomic_sub16(volatile StgWord16 *x, StgWord val); +extern StgWord hs_atomic_sub16(StgWord x, StgWord val); StgWord -hs_atomic_sub16(volatile StgWord16 *x, StgWord val) +hs_atomic_sub16(StgWord x, StgWord val) { - return __sync_fetch_and_sub(x, (StgWord16) val); + return __sync_fetch_and_sub((volatile StgWord16 *) x, (StgWord16) val); } -extern StgWord hs_atomic_sub32(volatile StgWord32 *x, StgWord val); +extern StgWord hs_atomic_sub32(StgWord x, StgWord val); StgWord -hs_atomic_sub32(volatile StgWord32 *x, StgWord val) +hs_atomic_sub32(StgWord x, StgWord val) { - return __sync_fetch_and_sub(x, (StgWord32) val); + return __sync_fetch_and_sub((volatile StgWord32 *) x, (StgWord32) val); } #if WORD_SIZE_IN_BITS == 64 -extern StgWord64 hs_atomic_sub64(volatile StgWord64 *x, StgWord64 val); +extern StgWord64 hs_atomic_sub64(StgWord x, StgWord64 val); StgWord64 -hs_atomic_sub64(volatile StgWord64 *x, StgWord64 val) +hs_atomic_sub64(StgWord x, StgWord64 val) { - return __sync_fetch_and_sub(x, val); + return __sync_fetch_and_sub((volatile StgWord64 *) x, val); } #endif // FetchAndByteArrayOp_Int -extern StgWord hs_atomic_and8(volatile StgWord8 *x, StgWord val); +extern StgWord hs_atomic_and8(StgWord x, StgWord val); StgWord -hs_atomic_and8(volatile StgWord8 *x, StgWord val) +hs_atomic_and8(StgWord x, StgWord val) { - return __sync_fetch_and_and(x, (StgWord8) val); + return __sync_fetch_and_and((volatile StgWord8 *) x, (StgWord8) val); } -extern StgWord hs_atomic_and16(volatile StgWord16 *x, StgWord val); +extern StgWord hs_atomic_and16(StgWord x, StgWord val); StgWord -hs_atomic_and16(volatile StgWord16 *x, StgWord val) +hs_atomic_and16(StgWord x, StgWord val) { - return __sync_fetch_and_and(x, (StgWord16) val); + return __sync_fetch_and_and((volatile StgWord16 *) x, (StgWord16) val); } -extern StgWord hs_atomic_and32(volatile StgWord32 *x, StgWord val); +extern StgWord hs_atomic_and32(StgWord x, StgWord val); StgWord -hs_atomic_and32(volatile StgWord32 *x, StgWord val) +hs_atomic_and32(StgWord x, StgWord val) { - return __sync_fetch_and_and(x, (StgWord32) val); + return __sync_fetch_and_and((volatile StgWord32 *) x, (StgWord32) val); } #if WORD_SIZE_IN_BITS == 64 -extern StgWord64 hs_atomic_and64(volatile StgWord64 *x, StgWord64 val); +extern StgWord64 hs_atomic_and64(StgWord x, StgWord64 val); StgWord64 -hs_atomic_and64(volatile StgWord64 *x, StgWord64 val) +hs_atomic_and64(StgWord x, StgWord64 val) { - return __sync_fetch_and_and(x, val); + return __sync_fetch_and_and((volatile StgWord64 *) x, val); } #endif @@ -117,204 +117,204 @@ return tmp; \ } -extern StgWord hs_atomic_nand8(volatile StgWord8 *x, StgWord val); +extern StgWord hs_atomic_nand8(StgWord x, StgWord val); StgWord -hs_atomic_nand8(volatile StgWord8 *x, StgWord val) +hs_atomic_nand8(StgWord x, StgWord val) { #ifdef __clang__ - CAS_NAND(x, (StgWord8) val) + CAS_NAND((volatile StgWord8 *) x, (StgWord8) val) #else - return __sync_fetch_and_nand(x, (StgWord8) val); + return __sync_fetch_and_nand((volatile StgWord8 *) x, (StgWord8) val); #endif } -extern StgWord hs_atomic_nand16(volatile StgWord16 *x, StgWord val); +extern StgWord hs_atomic_nand16(StgWord x, StgWord val); StgWord -hs_atomic_nand16(volatile StgWord16 *x, StgWord val) +hs_atomic_nand16(StgWord x, StgWord val) { #ifdef __clang__ - CAS_NAND(x, (StgWord16) val); + CAS_NAND((volatile StgWord16 *) x, (StgWord16) val); #else - return __sync_fetch_and_nand(x, (StgWord16) val); + return __sync_fetch_and_nand((volatile StgWord16 *) x, (StgWord16) val); #endif } -extern StgWord hs_atomic_nand32(volatile StgWord32 *x, StgWord val); +extern StgWord hs_atomic_nand32(StgWord x, StgWord val); StgWord -hs_atomic_nand32(volatile StgWord32 *x, StgWord val) +hs_atomic_nand32(StgWord x, StgWord val) { #ifdef __clang__ - CAS_NAND(x, (StgWord32) val); + CAS_NAND((volatile StgWord32 *) x, (StgWord32) val); #else - return __sync_fetch_and_nand(x, (StgWord32) val); + return __sync_fetch_and_nand((volatile StgWord32 *) x, (StgWord32) val); #endif } #if WORD_SIZE_IN_BITS == 64 -extern StgWord64 hs_atomic_nand64(volatile StgWord64 *x, StgWord64 val); +extern StgWord64 hs_atomic_nand64(StgWord x, StgWord64 val); StgWord64 -hs_atomic_nand64(volatile StgWord64 *x, StgWord64 val) +hs_atomic_nand64(StgWord x, StgWord64 val) { #ifdef __clang__ - CAS_NAND(x, val); + CAS_NAND((volatile StgWord64 *) x, val); #else - return __sync_fetch_and_nand(x, val); + return __sync_fetch_and_nand((volatile StgWord64 *) x, val); #endif } #endif // FetchOrByteArrayOp_Int -extern StgWord hs_atomic_or8(volatile StgWord8 *x, StgWord val); +extern StgWord hs_atomic_or8(StgWord x, StgWord val); StgWord -hs_atomic_or8(volatile StgWord8 *x, StgWord val) +hs_atomic_or8(StgWord x, StgWord val) { - return __sync_fetch_and_or(x, (StgWord8) val); + return __sync_fetch_and_or((volatile StgWord8 *) x, (StgWord8) val); } -extern StgWord hs_atomic_or16(volatile StgWord16 *x, StgWord val); +extern StgWord hs_atomic_or16(StgWord x, StgWord val); StgWord -hs_atomic_or16(volatile StgWord16 *x, StgWord val) +hs_atomic_or16(StgWord x, StgWord val) { - return __sync_fetch_and_or(x, (StgWord16) val); + return __sync_fetch_and_or((volatile StgWord16 *) x, (StgWord16) val); } -extern StgWord hs_atomic_or32(volatile StgWord32 *x, StgWord val); +extern StgWord hs_atomic_or32(StgWord x, StgWord val); StgWord -hs_atomic_or32(volatile StgWord32 *x, StgWord val) +hs_atomic_or32(StgWord x, StgWord val) { - return __sync_fetch_and_or(x, (StgWord32) val); + return __sync_fetch_and_or((volatile StgWord32 *) x, (StgWord32) val); } #if WORD_SIZE_IN_BITS == 64 -extern StgWord64 hs_atomic_or64(volatile StgWord64 *x, StgWord64 val); +extern StgWord64 hs_atomic_or64(StgWord x, StgWord64 val); StgWord64 -hs_atomic_or64(volatile StgWord64 *x, StgWord64 val) +hs_atomic_or64(StgWord x, StgWord64 val) { - return __sync_fetch_and_or(x, val); + return __sync_fetch_and_or((volatile StgWord64 *) x, val); } #endif // FetchXorByteArrayOp_Int -extern StgWord hs_atomic_xor8(volatile StgWord8 *x, StgWord val); +extern StgWord hs_atomic_xor8(StgWord x, StgWord val); StgWord -hs_atomic_xor8(volatile StgWord8 *x, StgWord val) +hs_atomic_xor8(StgWord x, StgWord val) { - return __sync_fetch_and_xor(x, (StgWord8) val); + return __sync_fetch_and_xor((volatile StgWord8 *) x, (StgWord8) val); } -extern StgWord hs_atomic_xor16(volatile StgWord16 *x, StgWord val); +extern StgWord hs_atomic_xor16(StgWord x, StgWord val); StgWord -hs_atomic_xor16(volatile StgWord16 *x, StgWord val) +hs_atomic_xor16(StgWord x, StgWord val) { - return __sync_fetch_and_xor(x, (StgWord16) val); + return __sync_fetch_and_xor((volatile StgWord16 *) x, (StgWord16) val); } -extern StgWord hs_atomic_xor32(volatile StgWord32 *x, StgWord val); +extern StgWord hs_atomic_xor32(StgWord x, StgWord val); StgWord -hs_atomic_xor32(volatile StgWord32 *x, StgWord val) +hs_atomic_xor32(StgWord x, StgWord val) { - return __sync_fetch_and_xor(x, (StgWord32) val); + return __sync_fetch_and_xor((volatile StgWord32 *) x, (StgWord32) val); } #if WORD_SIZE_IN_BITS == 64 -extern StgWord64 hs_atomic_xor64(volatile StgWord64 *x, StgWord64 val); +extern StgWord64 hs_atomic_xor64(StgWord x, StgWord64 val); StgWord64 -hs_atomic_xor64(volatile StgWord64 *x, StgWord64 val) +hs_atomic_xor64(StgWord x, StgWord64 val) { - return __sync_fetch_and_xor(x, val); + return __sync_fetch_and_xor((volatile StgWord64 *) x, val); } #endif // CasByteArrayOp_Int -extern StgWord hs_cmpxchg8(volatile StgWord8 *x, StgWord old, StgWord new); +extern StgWord hs_cmpxchg8(StgWord x, StgWord old, StgWord new); StgWord -hs_cmpxchg8(volatile StgWord8 *x, StgWord old, StgWord new) +hs_cmpxchg8(StgWord x, StgWord old, StgWord new) { - return __sync_val_compare_and_swap(x, (StgWord8) old, (StgWord8) new); + return __sync_val_compare_and_swap((volatile StgWord8 *) x, (StgWord8) old, (StgWord8) new); } -extern StgWord hs_cmpxchg16(volatile StgWord16 *x, StgWord old, StgWord new); +extern StgWord hs_cmpxchg16(StgWord x, StgWord old, StgWord new); StgWord -hs_cmpxchg16(volatile StgWord16 *x, StgWord old, StgWord new) +hs_cmpxchg16(StgWord x, StgWord old, StgWord new) { - return __sync_val_compare_and_swap(x, (StgWord16) old, (StgWord16) new); + return __sync_val_compare_and_swap((volatile StgWord16 *) x, (StgWord16) old, (StgWord16) new); } -extern StgWord hs_cmpxchg32(volatile StgWord32 *x, StgWord old, StgWord new); +extern StgWord hs_cmpxchg32(StgWord x, StgWord old, StgWord new); StgWord -hs_cmpxchg32(volatile StgWord32 *x, StgWord old, StgWord new) +hs_cmpxchg32(StgWord x, StgWord old, StgWord new) { - return __sync_val_compare_and_swap(x, (StgWord32) old, (StgWord32) new); + return __sync_val_compare_and_swap((volatile StgWord32 *) x, (StgWord32) old, (StgWord32) new); } #if WORD_SIZE_IN_BITS == 64 -extern StgWord hs_cmpxchg64(volatile StgWord64 *x, StgWord64 old, StgWord64 new); +extern StgWord hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new); StgWord -hs_cmpxchg64(volatile StgWord64 *x, StgWord64 old, StgWord64 new) +hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new) { - return __sync_val_compare_and_swap(x, old, new); + return __sync_val_compare_and_swap((volatile StgWord64 *) x, old, new); } #endif // AtomicReadByteArrayOp_Int -extern StgWord hs_atomicread8(volatile StgWord8 *x); +extern StgWord hs_atomicread8(StgWord x); StgWord -hs_atomicread8(volatile StgWord8 *x) +hs_atomicread8(StgWord x) { - return *x; + return *(volatile StgWord8 *) x; } -extern StgWord hs_atomicread16(volatile StgWord16 *x); +extern StgWord hs_atomicread16(StgWord x); StgWord -hs_atomicread16(volatile StgWord16 *x) +hs_atomicread16(StgWord x) { - return *x; + return *(volatile StgWord16 *) x; } -extern StgWord hs_atomicread32(volatile StgWord32 *x); +extern StgWord hs_atomicread32(StgWord x); StgWord -hs_atomicread32(volatile StgWord32 *x) +hs_atomicread32(StgWord x) { - return *x; + return *(volatile StgWord32 *) x; } -extern StgWord64 hs_atomicread64(volatile StgWord64 *x); +extern StgWord64 hs_atomicread64(StgWord x); StgWord64 -hs_atomicread64(volatile StgWord64 *x) +hs_atomicread64(StgWord x) { - return *x; + return *(volatile StgWord64 *) x; } // AtomicWriteByteArrayOp_Int -extern void hs_atomicwrite8(volatile StgWord8 *x, StgWord val); +extern void hs_atomicwrite8(StgWord x, StgWord val); void -hs_atomicwrite8(volatile StgWord8 *x, StgWord val) +hs_atomicwrite8(StgWord x, StgWord val) { - *x = (StgWord8) val; + *(volatile StgWord8 *) x = (StgWord8) val; } -extern void hs_atomicwrite16(volatile StgWord16 *x, StgWord val); +extern void hs_atomicwrite16(StgWord x, StgWord val); void -hs_atomicwrite16(volatile StgWord16 *x, StgWord val) +hs_atomicwrite16(StgWord x, StgWord val) { - *x = (StgWord16) val; + *(volatile StgWord16 *) x = (StgWord16) val; } -extern void hs_atomicwrite32(volatile StgWord32 *x, StgWord val); +extern void hs_atomicwrite32(StgWord x, StgWord val); void -hs_atomicwrite32(volatile StgWord32 *x, StgWord val) +hs_atomicwrite32(StgWord x, StgWord val) { - *x = (StgWord32) val; + *(volatile StgWord32 *) x = (StgWord32) val; } -extern void hs_atomicwrite64(volatile StgWord64 *x, StgWord64 val); +extern void hs_atomicwrite64(StgWord x, StgWord64 val); void -hs_atomicwrite64(volatile StgWord64 *x, StgWord64 val) +hs_atomicwrite64(StgWord x, StgWord64 val) { - *x = (StgWord64) val; + *(volatile StgWord64 *) x = (StgWord64) val; } diff --git a/cbits/ctz.c b/cbits/ctz.c --- a/cbits/ctz.c +++ b/cbits/ctz.c @@ -31,7 +31,7 @@ StgWord hs_ctz64(StgWord64 x) { -#if defined(__GNUC__) && defined(i386_HOST_ARCH) +#if defined(__GNUC__) && (defined(i386_HOST_ARCH) || defined(powerpc_HOST_ARCH)) /* On Linux/i386, the 64bit `__builtin_ctzll()` instrinsic doesn't get inlined by GCC but rather a short `__ctzdi2` runtime function is inserted when needed into compiled object files. diff --git a/changelog.md b/changelog.md new file mode 100644 --- /dev/null +++ b/changelog.md @@ -0,0 +1,38 @@ +## 0.5.0.0 + +- `GHC.Classes`: new `class IP (a :: Symbol) b | a -> b` + +- `GHC.Prim`: changed type signatures from + + check# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, () #) + finalizeWeak# :: Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, State# RealWorld -> (# State# RealWorld, () #) #) + mkWeak# :: a -> b -> c -> State# RealWorld -> (# State# RealWorld, Weak# b #) + + to + + check# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> State# RealWorld + finalizeWeak# :: Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, State# RealWorld -> (# State# RealWorld, b #) #) + mkWeak# :: a -> b -> (State# RealWorld -> (# State# RealWorld, c #)) -> State# RealWorld -> (# State# RealWorld, Weak# b #) + +- Removed from `GHC.Prim`: + + parAt# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int# + parAtAbs# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int# + parAtForNow# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int# + parAtRel# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int# + parGlobal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int# + parLocal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int# + +- Added to `GHC.Prim`: + + getSizeofMutableByteArray# :: MutableByteArray# d -> State# d -> (# State# d, Int# #) + subWordC# :: Word# -> Word# -> (# Word#, Int# #) + runRW# :: (State# RealWorld -> (# State# RealWorld, o #)) -> (# State# RealWorld, o #) + +- Added to `GHC.Types`: + + data Module = Module TrName TrName + data Nat + data Symbol + data TrName = TrNameS Addr# | TrNameD [Char] + data TyCon = TyCon Word# Word# Module TrName diff --git a/ghc-prim.cabal b/ghc-prim.cabal --- a/ghc-prim.cabal +++ b/ghc-prim.cabal @@ -1,6 +1,6 @@ name: ghc-prim -version: 0.4.0.0 --- GHC 7.8.4 released with 0.3.1.0 +version: 0.5.0.0 +-- NOTE: Don't forget to update ./changelog.md license: BSD3 license-file: LICENSE category: GHC @@ -8,10 +8,12 @@ bug-reports: http://ghc.haskell.org/trac/ghc/newticket?component=libraries%20%28other%29&keywords=ghc-prim synopsis: GHC primitives cabal-version: >=1.10 -build-type: Custom +build-type: Simple description: - GHC primitives. + This package contains the primitive types and operations supplied by GHC. +extra-source-files: changelog.md + source-repository head type: git location: http://git.haskell.org/ghc.git @@ -48,6 +50,20 @@ GHC.Tuple GHC.Types + -- OS Specific + if os(windows) + -- Windows requires some extra libraries for linking because the RTS + -- is no longer re-exporting them (see #11223) + -- msvcrt: standard C library. The RTS will automatically include this, + -- but is added for completeness. + -- mingwex: provides C99 compatibility. libm is a stub on MingW. + -- mingw32: Unfortunately required because of a resource leak between + -- mingwex and mingw32. the __math_err symbol is defined in + -- mingw32 which is required by mingwex. + -- user32: provides access to apis to modify user components (UI etc) + -- on Windows. Required because of mingw32. + extra-libraries: user32, mingw32, mingwex + if flag(include-ghc-prim) exposed-modules: GHC.Prim @@ -61,6 +77,6 @@ cbits/popcnt.c cbits/word2float.c - -- We need to set the package key to ghc-prim (without a version number) + -- We need to set the unit ID to ghc-prim (without a version number) -- as it's magic. - ghc-options: -this-package-key ghc-prim + ghc-options: -this-unit-id ghc-prim