-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Primeval world of Haskell.
--   
--   Please see the README on GitHub at
--   <a>https://github.com/lehins/primal#readme</a>
@package primal
@version 0.3.0.0


module Control.Prim.Monad.Throw

-- | A class for monads in which exceptions may be thrown.
--   
--   Instances should obey the following law:
--   
--   <pre>
--   throwM e &gt;&gt; x = throwM e
--   </pre>
--   
--   In other words, throwing an exception short-circuits the rest of the
--   monadic computation.
--   
--   <h3>Note</h3>
--   
--   This is an identical class to <a>MonadThrow</a> from
--   <tt>exceptions</tt> package. The reason why it was copied, instead of
--   a direct dependency on the aforementioned package is because
--   <tt>MonadCatch</tt> and <tt>MonadMask</tt> are not right abstractions
--   for exception handling in presence of concurrency and also because
--   instances for such transformers as <a>MaybeT</a> and <a>ExceptT</a>
--   are flawed.
class Monad m => MonadThrow m

-- | Throw an exception. Note that this throws when this action is run in
--   the monad <tt>m</tt>, not when it is applied. It is a generalization
--   of <a>Control.Prim.Exception</a>'s <a>throw</a>.
throwM :: (MonadThrow m, Exception e) => e -> m a
instance Control.Prim.Monad.Throw.MonadThrow GHC.Maybe.Maybe
instance (e GHC.Types.~ GHC.Exception.Type.SomeException) => Control.Prim.Monad.Throw.MonadThrow (Data.Either.Either e)
instance Control.Prim.Monad.Throw.MonadThrow GHC.Types.IO
instance Control.Prim.Monad.Throw.MonadThrow (GHC.ST.ST s)
instance Control.Prim.Monad.Throw.MonadThrow GHC.Conc.Sync.STM
instance Control.Prim.Monad.Throw.MonadThrow m => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.Cont.ContT r m)
instance (e GHC.Types.~ GHC.Exception.Type.SomeException, GHC.Base.Monad m) => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Prim.Monad.Throw.MonadThrow m => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.Identity.IdentityT m)
instance GHC.Base.Monad m => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.Maybe.MaybeT m)
instance Control.Prim.Monad.Throw.MonadThrow m => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.Reader.ReaderT r m)
instance (GHC.Base.Monoid w, Control.Prim.Monad.Throw.MonadThrow m) => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Base.Monoid w, Control.Prim.Monad.Throw.MonadThrow m) => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Prim.Monad.Throw.MonadThrow m => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Prim.Monad.Throw.MonadThrow m => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.State.Strict.StateT s m)
instance (GHC.Base.Monoid w, Control.Prim.Monad.Throw.MonadThrow m) => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (GHC.Base.Monoid w, Control.Prim.Monad.Throw.MonadThrow m) => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.Writer.Strict.WriterT w m)
instance (GHC.Base.Monoid w, Control.Prim.Monad.Throw.MonadThrow m) => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.Accum.AccumT w m)
instance Control.Prim.Monad.Throw.MonadThrow m => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.Select.SelectT r m)
instance Control.Prim.Monad.Throw.MonadThrow m => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.RWS.CPS.RWST r w st m)
instance Control.Prim.Monad.Throw.MonadThrow m => Control.Prim.Monad.Throw.MonadThrow (Control.Monad.Trans.Writer.CPS.WriterT w m)


module Control.Prim.Eval

-- | This is an action that ensures that the value is still available and
--   garbage collector has not cleaned it up.
--   
--   Make sure not to use it after some computation that doesn't return,
--   like after <tt>forever</tt> for example, otherwise touch will simply
--   be removed by ghc and bad things will happen. If you have a case like
--   that, make sure to use <tt>withAlivePrimBase</tt> or <a>keepAlive</a>
--   instead.
touch :: MonadPrim s m => a -> m ()

-- | Same as <a>touch#</a>, except it is not restricted to <a>RealWorld</a>
--   state token.
touch# :: a -> State# s -> State# s

-- | Similar to <a>touch</a>. See <tt>withAlive#</tt> for more info.
keepAlive :: MonadUnliftPrim s m => a -> m b -> m b

-- | Forward compatible operator that might be introduced in some future
--   ghc version.
--   
--   See: <a>#17760</a>
--   
--   Current version is not as efficient as the version that will be
--   introduced in the future, because it works around the ghc bug by
--   simply preventing inlining and relying on the <a>touch</a> function.
keepAlive# :: a -> (State# s -> (# State# s, r #)) -> State# s -> (# State# s, r #)

-- | The value of <tt>seq a b</tt> is bottom if <tt>a</tt> is bottom, and
--   otherwise equal to <tt>b</tt>. In other words, it evaluates the first
--   argument <tt>a</tt> to weak head normal form (WHNF). <tt>seq</tt> is
--   usually introduced to improve performance by avoiding unneeded
--   laziness.
--   
--   A note on evaluation order: the expression <tt>seq a b</tt> does
--   <i>not</i> guarantee that <tt>a</tt> will be evaluated before
--   <tt>b</tt>. The only guarantee given by <tt>seq</tt> is that the both
--   <tt>a</tt> and <tt>b</tt> will be evaluated before <tt>seq</tt>
--   returns a value. In particular, this means that <tt>b</tt> may be
--   evaluated before <tt>a</tt>. If you need to guarantee a specific order
--   of evaluation, you must use the function <tt>pseq</tt> from the
--   "parallel" package.
seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b
infixr 0 `seq`

-- | An action that evaluates a value to Weak Head Normal Form (WHNF). Same
--   as <a>evaluate</a>, except it works in <a>MonadPrim</a>. This function
--   provides stronger guarantees than <a>seq</a> with respect to ordering
--   of operations, but it does have a slightly higher overhead.
eval :: MonadPrim s m => a -> m a

-- | Run the action and then use <a>eval</a> to ensure its result is
--   evaluated to Weak Head Normal Form (WHNF)
evalM :: MonadPrim s m => m a -> m a

-- | An action that evaluates a value to Normal Form (NF). This function
--   provides stronger guarantees than <a>deepseq</a> with respect to
--   ordering of operations.
deepeval :: (MonadPrim s m, NFData a) => a -> m a

-- | Run the action and the using <a>deepeval</a> ensure its result is
--   evaluated to Normal Form (NF)
deepevalM :: (MonadPrim s m, NFData a) => m a -> m a

-- | Bogus Normal Form. This is useful in places where <a>NFData</a>
--   constraint is required, but an instance can't really be created in any
--   meaningful way for the type at hand. Creating environment in
--   benchmarks is one such place where it may come in handy.
newtype BNF a
BNF :: a -> BNF a
instance Control.DeepSeq.NFData (Control.Prim.Eval.BNF a)


module Control.Prim.Monad

-- | A shorter synonym for the magical <a>RealWorld</a>
type RW = RealWorld

-- | <tt>RealWorld</tt> is deeply magical. It is <i>primitive</i>, but it
--   is not <i>unlifted</i> (hence <tt>ptrArg</tt>). We never manipulate
--   values of type <tt>RealWorld</tt>; it's only used in the type system,
--   to parameterise <tt>State#</tt>.
data RealWorld
type MonadIO m = MonadPrim RW m
class MonadThrow m => MonadPrim s m | m -> s

-- | Construct a primitive action
prim :: MonadPrim s m => (State# s -> (# State# s, a #)) -> m a
class MonadUnliftPrim s m => MonadPrimBase s m

-- | Unwrap a primitive action
primBase :: MonadPrimBase s m => m a -> State# s -> (# State# s, a #)
type MonadUnliftIO m = MonadUnliftPrim RW m
class MonadPrim s m => MonadUnliftPrim s m
withRunInST :: MonadUnliftPrim s m => ((forall a. m a -> ST s a) -> ST s b) -> m b
runInPrimBase1 :: MonadUnliftPrim s m => (a -> m b) -> ((a -> State# s -> (# State# s, b #)) -> State# s -> (# State# s, c #)) -> m c
runInPrimBase2 :: MonadUnliftPrim s m => (a -> m b) -> (c -> m d) -> ((a -> State# s -> (# State# s, b #)) -> (c -> State# s -> (# State# s, d #)) -> State# s -> (# State# s, e #)) -> m e

-- | The strict <a>ST</a> monad. The <a>ST</a> monad allows for destructive
--   updates, but is escapable (unlike IO). A computation of type
--   <tt><a>ST</a> s a</tt> returns a value of type <tt>a</tt>, and execute
--   in "thread" <tt>s</tt>. The <tt>s</tt> parameter is either
--   
--   <ul>
--   <li>an uninstantiated type variable (inside invocations of
--   <a>runST</a>), or</li>
--   <li><a>RealWorld</a> (inside invocations of <a>stToIO</a>).</li>
--   </ul>
--   
--   It serves to keep the internal states of different invocations of
--   <a>runST</a> separate from each other and from invocations of
--   <a>stToIO</a>.
--   
--   The <a>&gt;&gt;=</a> and <a>&gt;&gt;</a> operations are strict in the
--   state (though not in values stored in the state). For example,
--   
--   <pre>
--   <a>runST</a> (writeSTRef _|_ v &gt;&gt;= f) = _|_
--   </pre>
data ST s a
unIO :: IO a -> State# RealWorld -> (# State# RealWorld, a #)

-- | Unwrap <a>IO</a> that returns unit
unIO_ :: IO () -> State# RW -> State# RW

-- | Unwrap <a>ST</a>
unST :: ST s a -> State# s -> (# State# s, a #)

-- | Unwrap <a>ST</a> that returns unit
unST_ :: ST s () -> State# s -> State# s

-- | Return the value computed by a state thread. The <tt>forall</tt>
--   ensures that the internal state used by the <a>ST</a> computation is
--   inaccessible to the rest of the program.
runST :: (forall s. () => ST s a) -> a

-- | Construct a primitive action that does not return anything.
prim_ :: MonadPrim s m => (State# s -> State# s) -> m ()
primBase_ :: MonadPrimBase s m => m () -> State# s -> State# s
withRunInIO :: forall m b. MonadUnliftPrim RW m => ((forall a. m a -> IO a) -> IO b) -> m b
withRunInPrimBase :: (MonadUnliftPrim s m, MonadPrimBase s n) => ((forall a. m a -> n a) -> n b) -> m b
runInPrimBase :: forall s m a b. MonadUnliftPrim s m => m a -> ((State# s -> (# State# s, a #)) -> State# s -> (# State# s, b #)) -> m b

-- | Lift an <a>IO</a> action to <a>MonadPrim</a> with the <a>RealWorld</a>
--   state token. Type restricted synonym for <a>liftPrimBase</a>
liftIO :: MonadPrim RW m => IO a -> m a

-- | Lift an <a>ST</a> action to <a>MonadPrim</a> with the same state
--   token. Type restricted synonym for <a>liftPrimBase</a>
liftST :: MonadPrim s m => ST s a -> m a

-- | Lift an action from the <a>MonadPrimBase</a> to another
--   <a>MonadPrim</a> with the same state token.
liftPrimBase :: (MonadPrimBase s n, MonadPrim s m) => n a -> m a

-- | Restrict a <a>MonadPrimBase</a> action that works with
--   <a>RealWorld</a> to <a>IO</a>.
primBaseToIO :: MonadPrimBase RealWorld m => m a -> IO a

-- | Restrict a <a>MonadPrimBase</a> action that works in <a>ST</a>.
primBaseToST :: MonadPrimBase s m => m a -> ST s a

-- | An action that evaluates a value to Weak Head Normal Form (WHNF). Same
--   as <a>evaluate</a>, except it works in <a>MonadPrim</a>. This function
--   provides stronger guarantees than <a>seq</a> with respect to ordering
--   of operations, but it does have a slightly higher overhead.
eval :: MonadPrim s m => a -> m a

-- | Run the action and then use <a>eval</a> to ensure its result is
--   evaluated to Weak Head Normal Form (WHNF)
evalM :: MonadPrim s m => m a -> m a

-- | A class of types that can be fully evaluated.
class NFData a

-- | An action that evaluates a value to Normal Form (NF). This function
--   provides stronger guarantees than <a>deepseq</a> with respect to
--   ordering of operations.
deepeval :: (MonadPrim s m, NFData a) => a -> m a

-- | Run the action and the using <a>deepeval</a> ensure its result is
--   evaluated to Normal Form (NF)
deepevalM :: (MonadPrim s m, NFData a) => m a -> m a

-- | Similar to <a>when</a>, but condional is supplied in a form of monadic
--   action rather than a pure value.
whenM :: Monad m => m Bool -> m () -> m ()

-- | Similar to <a>unless</a>, but condional is supplied in a form of
--   monadic action rather than a pure value.
unlessM :: Monad m => m Bool -> m () -> m ()


module Control.Prim.Monad.Unsafe

-- | Coerce the state token of prim operation and wrap it into a
--   <a>MonadPrim</a> action.
--   
--   <h3>Highly unsafe!</h3>
unsafePrim :: MonadPrim s m => (State# s' -> (# State# s', a #)) -> m a

-- | Coerce the state token of prim operation and wrap it into a
--   <a>MonadPrim</a> action.
--   
--   <h3>Highly unsafe!</h3>
unsafePrim_ :: MonadPrim s m => (State# s' -> State# s') -> m ()

-- | Unwrap any <a>MonadPrimBase</a> action while coercing the state token
--   
--   <h3>Highly unsafe!</h3>
unsafePrimBase :: MonadPrimBase s' m => m a -> State# s -> (# State# s, a #)

-- | Unwrap any <a>MonadPrimBase</a> action that does not return anything,
--   while coercing the state token
--   
--   <h3>Highly unsafe!</h3>
unsafePrimBase_ :: MonadPrimBase s' m => m () -> State# s -> State# s

-- | Convert a <a>MonadPrimBase</a> action to another <a>MonadPrim</a>
--   while coercing the state token.
--   
--   <h3>Highly unsafe!</h3>
unsafePrimBaseToPrim :: (MonadPrimBase sn n, MonadPrim sm m) => n a -> m a

-- | Convert a <a>MonadPrimBase</a> action to <a>IO</a> while coercing the
--   state token to <a>RealWorld</a>.
--   
--   <h3>Highly unsafe!</h3>
unsafePrimBaseToIO :: MonadPrimBase s m => m a -> IO a

-- | Convert a <a>MonadPrimBase</a> action to <a>ST</a> while coercing the
--   state token <tt>s</tt>.
--   
--   <h3>Highly unsafe!</h3>
unsafePrimBaseToST :: MonadPrimBase sm m => m a -> ST s a

-- | Convert an <a>IO</a> action to some <a>MonadPrim</a> while coercing
--   the state token.
--   
--   <h3>Highly unsafe!</h3>
--   
--   It is similar to <a>unsafeSTToIO</a>, except resulting action can be
--   any other <a>MonadPrim</a> action, therefore it is a lot more
--   dangerous.
unsafeIOToPrim :: MonadPrim s m => IO a -> m a

-- | Convert an <a>ST</a> action to some <a>MonadPrim</a> while coercing
--   the state token.
--   
--   <h3>Highly unsafe!</h3>
unsafeSTToPrim :: MonadPrim s' m => ST s a -> m a

-- | A version of <a>liftPrimBase</a> that coerce the state token.
--   
--   <h3>Highly unsafe!</h3>
unsafeLiftPrimBase :: forall sn n sm m a. (MonadPrimBase sn n, MonadPrim sm m) => n a -> m a

-- | Same as <a>noDuplicate</a>, except works in any <a>MonadPrim</a>.
noDuplicatePrim :: MonadPrim s m => m ()

-- | Same as <a>unsafeDupablePerformIO</a>, except works not only with
--   <a>IO</a>, but with other <a>MonadPrimBase</a> actions as well.
--   Reading and writing values into memory is safe, as long as writing
--   action is idempotent. On the other hand things like memory or resource
--   allocation, exceptions handling are not safe at all, since supplied
--   action can be run multiple times and a copy interrupted at will.
unsafeDupablePerformPrimBase :: MonadPrimBase s m => m a -> a

-- | Take an <a>IO</a> and compute it as a pure value, while inlining the
--   action itself.
--   
--   <h3>Ridiculously unsafe!</h3>
--   
--   This is even more unsafe then both <a>unsafePerformIO</a> and
--   <a>unsafeDupableInterleaveIO</a>.
--   
--   The only time it is really safe to use is on idempotent action that
--   only read values from memory, but do note do any mutation, allocation
--   and certainly not interaction with real world.
--   
--   In <a><tt>bytestring</tt></a> it is known as
--   <tt>accursedUnutterablePerformIO</tt>. Here are some resources that
--   discuss it's unsafety:
--   
--   <ul>
--   <li><a>Stack overflow question</a></li>
--   <li><a>Reddit discussion</a></li>
--   </ul>
unsafeInlineIO :: IO a -> a

-- | Take an <a>ST</a> and compute it as a pure value, while inlining the
--   action itself. Same as <a>unsafeInlineIO</a>.
--   
--   <h3>Ridiculously unsafe!</h3>
unsafeInlineST :: ST s a -> a

-- | Take any <a>MonadPrimBase</a> action and compute it as a pure value,
--   while inlining the action. Same as <a>unsafeInlineIO</a>, but applied
--   to any <a>MonadPrimBase</a> action.
--   
--   <h3>Ridiculously unsafe!</h3>
unsafeInlinePrimBase :: MonadPrimBase s m => m a -> a

-- | Same as <a>unsafeInterleaveIO</a>, except works in any
--   <a>MonadPrimBase</a>
unsafeInterleavePrimBase :: MonadPrimBase s m => m a -> m a

-- | Same as <a>unsafeDupableInterleaveIO</a>, except works in any
--   <a>MonadPrimBase</a>
unsafeDupableInterleavePrimBase :: MonadPrimBase s m => m a -> m a

-- | This is the "back door" into the <a>IO</a> monad, allowing <a>IO</a>
--   computation to be performed at any time. For this to be safe, the
--   <a>IO</a> computation should be free of side effects and independent
--   of its environment.
--   
--   If the I/O computation wrapped in <a>unsafePerformIO</a> performs side
--   effects, then the relative order in which those side effects take
--   place (relative to the main I/O trunk, or other calls to
--   <a>unsafePerformIO</a>) is indeterminate. Furthermore, when using
--   <a>unsafePerformIO</a> to cause side-effects, you should take the
--   following precautions to ensure the side effects are performed as many
--   times as you expect them to be. Note that these precautions are
--   necessary for GHC, but may not be sufficient, and other compilers may
--   require different precautions:
--   
--   <ul>
--   <li>Use <tt>{-# NOINLINE foo #-}</tt> as a pragma on any function
--   <tt>foo</tt> that calls <a>unsafePerformIO</a>. If the call is
--   inlined, the I/O may be performed more than once.</li>
--   <li>Use the compiler flag <tt>-fno-cse</tt> to prevent common
--   sub-expression elimination being performed on the module, which might
--   combine two side effects that were meant to be separate. A good
--   example is using multiple global variables (like <tt>test</tt> in the
--   example below).</li>
--   <li>Make sure that the either you switch off let-floating
--   (<tt>-fno-full-laziness</tt>), or that the call to
--   <a>unsafePerformIO</a> cannot float outside a lambda. For example, if
--   you say: <tt> f x = unsafePerformIO (newIORef []) </tt> you may get
--   only one reference cell shared between all calls to <tt>f</tt>. Better
--   would be <tt> f x = unsafePerformIO (newIORef [x]) </tt> because now
--   it can't float outside the lambda.</li>
--   </ul>
--   
--   It is less well known that <a>unsafePerformIO</a> is not type safe.
--   For example:
--   
--   <pre>
--   test :: IORef [a]
--   test = unsafePerformIO $ newIORef []
--   
--   main = do
--           writeIORef test [42]
--           bang &lt;- readIORef test
--           print (bang :: [Char])
--   </pre>
--   
--   This program will core dump. This problem with polymorphic references
--   is well known in the ML community, and does not arise with normal
--   monadic use of references. There is no easy way to make it impossible
--   once you use <a>unsafePerformIO</a>. Indeed, it is possible to write
--   <tt>coerce :: a -&gt; b</tt> with the help of <a>unsafePerformIO</a>.
--   So be careful!
unsafePerformIO :: IO a -> a

-- | This version of <a>unsafePerformIO</a> is more efficient because it
--   omits the check that the IO is only being performed by a single
--   thread. Hence, when you use <a>unsafeDupablePerformIO</a>, there is a
--   possibility that the IO action may be performed multiple times (on a
--   multiprocessor), and you should therefore ensure that it gives the
--   same results each time. It may even happen that one of the duplicated
--   IO actions is only run partially, and then interrupted in the middle
--   without an exception being raised. Therefore, functions like
--   <a>bracket</a> cannot be used safely within
--   <a>unsafeDupablePerformIO</a>.
unsafeDupablePerformIO :: IO a -> a

-- | <a>unsafeInterleaveIO</a> allows an <a>IO</a> computation to be
--   deferred lazily. When passed a value of type <tt>IO a</tt>, the
--   <a>IO</a> will only be performed when the value of the <tt>a</tt> is
--   demanded. This is used to implement lazy file reading, see
--   <a>hGetContents</a>.
unsafeInterleaveIO :: IO a -> IO a

-- | <a>unsafeDupableInterleaveIO</a> allows an <a>IO</a> computation to be
--   deferred lazily. When passed a value of type <tt>IO a</tt>, the
--   <a>IO</a> will only be performed when the value of the <tt>a</tt> is
--   demanded.
--   
--   The computation may be performed multiple times by different threads,
--   possibly at the same time. To ensure that the computation is performed
--   only once, use <a>unsafeInterleaveIO</a> instead.
unsafeDupableInterleaveIO :: IO a -> IO a


module Control.Prim.Exception

-- | This is the same as <tt>throwIO</tt>, but works with any
--   <a>MonadPrim</a> without restriction on <a>RealWorld</a>.
throw :: (Exception e, MonadPrim s m) => e -> m a

-- | Similar to <a>throwTo</a>, except that it wraps any known non-async
--   exception with <tt>SomeAsyncException</tt>. This is necessary, because
--   receiving thread will get the exception in an asynchronous manner and
--   without proper wrapping it will not be able to distinguish it from a
--   regular synchronous exception
throwTo :: (MonadPrim s m, Exception e) => ThreadId -> e -> m ()

-- | Raise an impure exception from pure code. Returns a thunk, which will
--   result in a supplied exceptionn being thrown when evaluated.
impureThrow :: Exception e => e -> a

-- | Behaves exactly as <a>catch</a>, except that it works in any
--   <a>MonadUnliftPrim</a>.
catch :: forall e a m. (Exception e, MonadUnliftPrim RW m) => m a -> (e -> m a) -> m a
catchAny :: forall a m. MonadUnliftPrim RW m => m a -> (SomeException -> m a) -> m a
catchAnySync :: forall a m. MonadUnliftPrim RW m => m a -> (SomeException -> m a) -> m a
catchAll :: forall a m. MonadUnliftPrim RW m => m a -> (forall e. Exception e => e -> m a) -> m a
catchAllSync :: forall a m. MonadUnliftPrim RW m => m a -> (forall e. Exception e => e -> m a) -> m a
try :: (Exception e, MonadUnliftPrim RW m) => m a -> m (Either e a)
tryAny :: MonadUnliftPrim RW m => m a -> m (Either SomeException a)
tryAnySync :: MonadUnliftPrim RW m => m a -> m (Either SomeException a)

-- | Async safe version of <a>onException</a>.
onException :: MonadUnliftPrim RW m => m a -> m b -> m a

-- | Run an action, while invoking an exception handler if that action
--   fails for some reason. Exception handling function has async
--   exceptions masked, but it is still interruptible, which can be
--   undesired in some scenarios. If you are sure that the cleanup action
--   does not deadlock and you do need hard guarantees that it gets
--   executed you can run it as uninterruptible:
--   
--   <pre>
--   uninterruptibleMask $ \restore -&gt; withException (restore action) handler
--   </pre>
withException :: (MonadUnliftPrim RW m, Exception e) => m a -> (e -> m b) -> m a

-- | Same as <a>withException</a>, but will invoke exception handling
--   function on all exceptions.
withAnyException :: MonadUnliftPrim RW m => m a -> (SomeException -> m b) -> m a
finally :: MonadUnliftPrim RW m => m a -> m b -> m a
bracket :: MonadUnliftPrim RW m => m a -> (a -> m b) -> (a -> m c) -> m c
bracket_ :: MonadUnliftPrim RW m => m a -> m b -> m c -> m c
bracketOnError :: MonadUnliftPrim RW m => m a -> (a -> m b) -> (a -> m c) -> m c
ufinally :: MonadUnliftPrim RW m => m a -> m b -> m a
ubracket :: MonadUnliftPrim RW m => m a -> (a -> m b) -> (a -> m c) -> m c
ubracket_ :: MonadUnliftPrim RW m => m a -> m b -> m c -> m c
ubracketOnError :: MonadUnliftPrim RW m => m a -> (a -> m b) -> (a -> m c) -> m c

-- | Mask all asychronous exceptions, but keep it interruptible, unless the
--   inherited state was uninterruptible already, in which case this action
--   has no affect. Same as <a>mask</a>, except that it is polymorphic in
--   state token. Inside a state thread it cannot affect the result of
--   computation, therefore it is safe to use it within <a>ST</a> monad.
mask :: forall a m s. MonadUnliftPrim s m => ((forall b. m b -> m b) -> m a) -> m a

-- | Mask all asychronous exceptions, but keep it interruptible, unless the
--   inherited state was uninterruptible already, in which case this action
--   has no affect. Same as <a>mask_</a>, except that it is polymorphic in
--   state token. Inside a state thread it cannot affect the result of
--   computation, therefore it is safe to use it within <a>ST</a> monad.
mask_ :: forall a m s. MonadUnliftPrim s m => m a -> m a
maskPrimBase_ :: forall a n m s. (MonadPrim s m, MonadPrimBase s n) => n a -> m a

-- | Mask all asychronous exceptions and mark it uninterruptible. Same as
--   <a>uninterruptibleMask</a>, except that it is polymorphic in state
--   token. Inside a state thread it cannot affect the result of
--   computation, therefore it is safe to use it within <a>ST</a> monad.
uninterruptibleMask :: forall a m s. MonadUnliftPrim s m => ((forall b. m b -> m b) -> m a) -> m a

-- | Mask all async exceptions and make sure evaluation cannot be
--   interrupted. It is polymorphic in the state token because it is
--   perfectly safe to use with <a>ST</a> actions that don't perform any
--   allocations. It doesn't have to be restricted to <a>RealWorld</a>
--   because it has no impact on other threads and can't affect the result
--   of computation, moreover pure functions that implement tight loops are
--   already non-interruptible. In fact using this function is more
--   dangerous in <a>IO</a> than it is in <a>ST</a>, because misuse can
--   lead to deadlocks in a concurrent setting.
uninterruptibleMask_ :: forall a m s. MonadUnliftPrim s m => m a -> m a
uninterruptibleMaskPrimBase_ :: forall a n m s. (MonadPrimBase s n, MonadPrim s m) => n a -> m a

-- | A direct wrapper around <a>maskAsyncExceptions#</a> primop. This is
--   different and more dangerous than <a>mask_</a> because it can turn
--   uninterrubtable state into interruptable.
maskAsyncExceptions :: forall a m. MonadUnliftPrim RW m => m a -> m a

-- | A direct wrapper around <a>unmaskAsyncExceptions#</a> primop.
unmaskAsyncExceptions :: forall a m. MonadUnliftPrim RW m => m a -> m a

-- | A direct wrapper around <a>maskUninterruptible#</a> primop.
maskUninterruptible :: forall a m. MonadUnliftPrim RW m => m a -> m a

-- | Describes the behaviour of a thread when an asynchronous exception is
--   received.
data MaskingState

-- | asynchronous exceptions are unmasked (the normal state)
Unmasked :: MaskingState

-- | the state during <a>mask</a>: asynchronous exceptions are masked, but
--   blocking operations may still be interrupted
MaskedInterruptible :: MaskingState

-- | the state during <a>uninterruptibleMask</a>: asynchronous exceptions
--   are masked, and blocking operations may not be interrupted
MaskedUninterruptible :: MaskingState

-- | Same as <a>getMaskingState</a>, but generalized to <a>MonadPrim</a>
getMaskingState :: MonadPrim RW m => m MaskingState

-- | Any type that you wish to throw or catch as an exception must be an
--   instance of the <tt>Exception</tt> class. The simplest case is a new
--   exception type directly below the root:
--   
--   <pre>
--   data MyException = ThisException | ThatException
--       deriving Show
--   
--   instance Exception MyException
--   </pre>
--   
--   The default method definitions in the <tt>Exception</tt> class do what
--   we need in this case. You can now throw and catch
--   <tt>ThisException</tt> and <tt>ThatException</tt> as exceptions:
--   
--   <pre>
--   *Main&gt; throw ThisException `catch` \e -&gt; putStrLn ("Caught " ++ show (e :: MyException))
--   Caught ThisException
--   </pre>
--   
--   In more complicated examples, you may wish to define a whole hierarchy
--   of exceptions:
--   
--   <pre>
--   ---------------------------------------------------------------------
--   -- Make the root exception type for all the exceptions in a compiler
--   
--   data SomeCompilerException = forall e . Exception e =&gt; SomeCompilerException e
--   
--   instance Show SomeCompilerException where
--       show (SomeCompilerException e) = show e
--   
--   instance Exception SomeCompilerException
--   
--   compilerExceptionToException :: Exception e =&gt; e -&gt; SomeException
--   compilerExceptionToException = toException . SomeCompilerException
--   
--   compilerExceptionFromException :: Exception e =&gt; SomeException -&gt; Maybe e
--   compilerExceptionFromException x = do
--       SomeCompilerException a &lt;- fromException x
--       cast a
--   
--   ---------------------------------------------------------------------
--   -- Make a subhierarchy for exceptions in the frontend of the compiler
--   
--   data SomeFrontendException = forall e . Exception e =&gt; SomeFrontendException e
--   
--   instance Show SomeFrontendException where
--       show (SomeFrontendException e) = show e
--   
--   instance Exception SomeFrontendException where
--       toException = compilerExceptionToException
--       fromException = compilerExceptionFromException
--   
--   frontendExceptionToException :: Exception e =&gt; e -&gt; SomeException
--   frontendExceptionToException = toException . SomeFrontendException
--   
--   frontendExceptionFromException :: Exception e =&gt; SomeException -&gt; Maybe e
--   frontendExceptionFromException x = do
--       SomeFrontendException a &lt;- fromException x
--       cast a
--   
--   ---------------------------------------------------------------------
--   -- Make an exception type for a particular frontend compiler exception
--   
--   data MismatchedParentheses = MismatchedParentheses
--       deriving Show
--   
--   instance Exception MismatchedParentheses where
--       toException   = frontendExceptionToException
--       fromException = frontendExceptionFromException
--   </pre>
--   
--   We can now catch a <tt>MismatchedParentheses</tt> exception as
--   <tt>MismatchedParentheses</tt>, <tt>SomeFrontendException</tt> or
--   <tt>SomeCompilerException</tt>, but not other types, e.g.
--   <tt>IOException</tt>:
--   
--   <pre>
--   *Main&gt; throw MismatchedParentheses `catch` \e -&gt; putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
--   Caught MismatchedParentheses
--   *Main&gt; throw MismatchedParentheses `catch` \e -&gt; putStrLn ("Caught " ++ show (e :: SomeFrontendException))
--   Caught MismatchedParentheses
--   *Main&gt; throw MismatchedParentheses `catch` \e -&gt; putStrLn ("Caught " ++ show (e :: SomeCompilerException))
--   Caught MismatchedParentheses
--   *Main&gt; throw MismatchedParentheses `catch` \e -&gt; putStrLn ("Caught " ++ show (e :: IOException))
--   *** Exception: MismatchedParentheses
--   </pre>
class (Typeable e, Show e) => Exception e
toException :: Exception e => e -> SomeException
fromException :: Exception e => SomeException -> Maybe e

-- | Render this exception value in a human-friendly manner.
--   
--   Default implementation: <tt><a>show</a></tt>.
displayException :: Exception e => e -> String

-- | The <tt>SomeException</tt> type is the root of the exception type
--   hierarchy. When an exception of type <tt>e</tt> is thrown, behind the
--   scenes it is encapsulated in a <tt>SomeException</tt>.
data SomeException

-- | Asynchronous exceptions.
data AsyncException

-- | The current thread's stack exceeded its limit. Since an exception has
--   been raised, the thread's stack will certainly be below its limit
--   again, but the programmer should take remedial action immediately.
StackOverflow :: AsyncException

-- | The program's heap is reaching its limit, and the program should take
--   action to reduce the amount of live data it has. Notes:
--   
--   <ul>
--   <li>It is undefined which thread receives this exception. GHC
--   currently throws this to the same thread that receives
--   <a>UserInterrupt</a>, but this may change in the future.</li>
--   <li>The GHC RTS currently can only recover from heap overflow if it
--   detects that an explicit memory limit (set via RTS flags). has been
--   exceeded. Currently, failure to allocate memory from the operating
--   system results in immediate termination of the program.</li>
--   </ul>
HeapOverflow :: AsyncException

-- | This exception is raised by another thread calling <a>killThread</a>,
--   or by the system if it needs to terminate the thread for some reason.
ThreadKilled :: AsyncException

-- | This exception is raised by default in the main thread of the program
--   when the user requests to terminate the program via the usual
--   mechanism(s) (e.g. Control-C in the console).
UserInterrupt :: AsyncException

-- | Superclass for asynchronous exceptions.
data SomeAsyncException
SomeAsyncException :: e -> SomeAsyncException
isSyncException :: Exception e => e -> Bool
isAsyncException :: Exception e => e -> Bool

asyncExceptionToException :: Exception e => e -> SomeException

asyncExceptionFromException :: Exception e => SomeException -> Maybe e

-- | This is thrown when the user calls <a>error</a>. The first
--   <tt>String</tt> is the argument given to <a>error</a>, second
--   <tt>String</tt> is the location.
data ErrorCall
ErrorCallWithLocation :: String -> String -> ErrorCall
pattern ErrorCall :: String -> ErrorCall

-- | Arithmetic exceptions.
data ArithException
Overflow :: ArithException
Underflow :: ArithException
LossOfPrecision :: ArithException
DivideByZero :: ArithException
Denormal :: ArithException

RatioZeroDenominator :: ArithException

-- | Exceptions generated by array operations
data ArrayException

-- | An attempt was made to index an array outside its declared bounds.
IndexOutOfBounds :: String -> ArrayException

-- | An attempt was made to evaluate an element of an array that had not
--   been initialized.
UndefinedElement :: String -> ArrayException

-- | <a>assert</a> was applied to <a>False</a>.
newtype AssertionFailed
AssertionFailed :: String -> AssertionFailed

-- | Exceptions that occur in the <tt>IO</tt> monad. An
--   <tt>IOException</tt> records a more specific error type, a descriptive
--   string and maybe the handle that was used when the error was flagged.
data IOException

-- | Thrown when the runtime system detects that the computation is
--   guaranteed not to terminate. Note that there is no guarantee that the
--   runtime system will notice whether any given computation is guaranteed
--   to terminate or not.
data NonTermination
NonTermination :: NonTermination

-- | Thrown when the program attempts to call <tt>atomically</tt>, from the
--   <tt>stm</tt> package, inside another call to <tt>atomically</tt>.
data NestedAtomically
NestedAtomically :: NestedAtomically

-- | The thread is blocked on an <tt>MVar</tt>, but there are no other
--   references to the <tt>MVar</tt> so it can't ever continue.
data BlockedIndefinitelyOnMVar
BlockedIndefinitelyOnMVar :: BlockedIndefinitelyOnMVar

-- | The thread is waiting to retry an STM transaction, but there are no
--   other references to any <tt>TVar</tt>s involved, so it can't ever
--   continue.
data BlockedIndefinitelyOnSTM
BlockedIndefinitelyOnSTM :: BlockedIndefinitelyOnSTM

-- | This thread has exceeded its allocation limit. See
--   <a>setAllocationCounter</a> and <a>enableAllocationLimit</a>.
data AllocationLimitExceeded
AllocationLimitExceeded :: AllocationLimitExceeded

-- | There are no runnable threads, so the program is deadlocked. The
--   <tt>Deadlock</tt> exception is raised in the main thread only.
data Deadlock
Deadlock :: Deadlock

-- | <a>CallStack</a>s are a lightweight method of obtaining a partial
--   call-stack at any point in the program.
--   
--   A function can request its call-site with the <a>HasCallStack</a>
--   constraint. For example, we can define
--   
--   <pre>
--   putStrLnWithCallStack :: HasCallStack =&gt; String -&gt; IO ()
--   </pre>
--   
--   as a variant of <tt>putStrLn</tt> that will get its call-site and
--   print it, along with the string given as argument. We can access the
--   call-stack inside <tt>putStrLnWithCallStack</tt> with
--   <a>callStack</a>.
--   
--   <pre>
--   putStrLnWithCallStack :: HasCallStack =&gt; String -&gt; IO ()
--   putStrLnWithCallStack msg = do
--     putStrLn msg
--     putStrLn (prettyCallStack callStack)
--   </pre>
--   
--   Thus, if we call <tt>putStrLnWithCallStack</tt> we will get a
--   formatted call-stack alongside our string.
--   
--   <pre>
--   &gt;&gt;&gt; putStrLnWithCallStack "hello"
--   hello
--   CallStack (from HasCallStack):
--     putStrLnWithCallStack, called at &lt;interactive&gt;:2:1 in interactive:Ghci1
--   </pre>
--   
--   GHC solves <a>HasCallStack</a> constraints in three steps:
--   
--   <ol>
--   <li>If there is a <a>CallStack</a> in scope -- i.e. the enclosing
--   function has a <a>HasCallStack</a> constraint -- GHC will append the
--   new call-site to the existing <a>CallStack</a>.</li>
--   <li>If there is no <a>CallStack</a> in scope -- e.g. in the GHCi
--   session above -- and the enclosing definition does not have an
--   explicit type signature, GHC will infer a <a>HasCallStack</a>
--   constraint for the enclosing definition (subject to the monomorphism
--   restriction).</li>
--   <li>If there is no <a>CallStack</a> in scope and the enclosing
--   definition has an explicit type signature, GHC will solve the
--   <a>HasCallStack</a> constraint for the singleton <a>CallStack</a>
--   containing just the current call-site.</li>
--   </ol>
--   
--   <a>CallStack</a>s do not interact with the RTS and do not require
--   compilation with <tt>-prof</tt>. On the other hand, as they are built
--   up explicitly via the <a>HasCallStack</a> constraints, they will
--   generally not contain as much information as the simulated call-stacks
--   maintained by the RTS.
--   
--   A <a>CallStack</a> is a <tt>[(String, SrcLoc)]</tt>. The
--   <tt>String</tt> is the name of function that was called, the
--   <a>SrcLoc</a> is the call-site. The list is ordered with the most
--   recently called function at the head.
--   
--   NOTE: The intrepid user may notice that <a>HasCallStack</a> is just an
--   alias for an implicit parameter <tt>?callStack :: CallStack</tt>. This
--   is an implementation detail and <b>should not</b> be considered part
--   of the <a>CallStack</a> API, we may decide to change the
--   implementation in the future.
data CallStack

-- | Request a CallStack.
--   
--   NOTE: The implicit parameter <tt>?callStack :: CallStack</tt> is an
--   implementation detail and <b>should not</b> be considered part of the
--   <a>CallStack</a> API, we may decide to change the implementation in
--   the future.
type HasCallStack = ?callStack :: CallStack

-- | Return the current <a>CallStack</a>.
--   
--   Does *not* include the call-site of <a>callStack</a>.
callStack :: HasCallStack => CallStack

-- | Extract a list of call-sites from the <a>CallStack</a>.
--   
--   The list is ordered by most recent call.
getCallStack :: CallStack -> [([Char], SrcLoc)]

-- | Pretty print a <a>CallStack</a>.
prettyCallStack :: CallStack -> String

-- | A single location in the source code.
data SrcLoc
SrcLoc :: [Char] -> [Char] -> [Char] -> Int -> Int -> Int -> Int -> SrcLoc
[srcLocPackage] :: SrcLoc -> [Char]
[srcLocModule] :: SrcLoc -> [Char]
[srcLocFile] :: SrcLoc -> [Char]
[srcLocStartLine] :: SrcLoc -> Int
[srcLocStartCol] :: SrcLoc -> Int
[srcLocEndLine] :: SrcLoc -> Int
[srcLocEndCol] :: SrcLoc -> Int

-- | Pretty print a <a>SrcLoc</a>.
prettySrcLoc :: SrcLoc -> String


module Control.Prim.Concurrent.MVar

-- | Mutable variable that can either be empty or full. Same as
--   <a>MVar</a>, but works with any state token therefore it is also
--   usable within <a>ST</a> monad.
data MVar a s
MVar :: MVar# s a -> MVar a s

-- | Checks whether supplied <a>MVar</a> is empty.
isEmptyMVar :: forall a m s. MonadPrim s m => MVar a s -> m Bool

-- | Checks whether supplied <a>MVar</a>s refer to the exact same one.
isSameMVar :: forall a s. MVar a s -> MVar a s -> Bool

-- | Construct an <a>MVar</a> with initial value in it, which is evaluated
--   to WHNF
newMVar :: forall a m s. MonadPrim s m => a -> m (MVar a s)

-- | Construct an <a>MVar</a> with initial value in it.
--   
--   Same as <a>newMVar</a> from <tt>base</tt>, but works in any
--   <a>MonadPrim</a>.
newLazyMVar :: forall a m s. MonadPrim s m => a -> m (MVar a s)

-- | Construct an <a>MVar</a> with initial value in it.
newDeepMVar :: forall a m s. (NFData a, MonadPrim s m) => a -> m (MVar a s)

-- | Construct an empty <a>MVar</a>.
--   
--   Same as <a>newEmptyMVar</a> from <tt>base</tt>, but works in any
--   <a>MonadPrim</a>.
newEmptyMVar :: forall a m s. MonadPrim s m => m (MVar a s)

-- | Write a value into an <a>MVar</a>. Blocks the current thread if
--   <a>MVar</a> is empty and waits until it gets filled by another thread.
--   Evaluates the argument to WHNF prior to writing it.
putMVar :: forall a m s. MonadPrim s m => MVar a s -> a -> m ()

-- | Same as <a>putMVar</a>, but allows to write a thunk into an MVar.
--   
--   Same as <a>putMVar</a> from <tt>base</tt>, but works in any
--   <a>MonadPrim</a>.
putLazyMVar :: forall a m s. MonadPrim s m => MVar a s -> a -> m ()

-- | Same as putMVar, but evaluates the argument to NF prior to writing it.
putDeepMVar :: forall a m s. (NFData a, MonadPrim s m) => MVar a s -> a -> m ()

-- | Attempt to write a value into <a>MVar</a>. Unlike <a>putMVar</a> this
--   function never blocks. It also returns <a>True</a> if <a>MVar</a> was
--   empty and placing the value in it turned out to be successfull and
--   <a>False</a> otherwise. Evaluates the supplied argumetn to WHNF prior
--   to attempting a write operation.
tryPutMVar :: forall a m s. MonadPrim s m => MVar a s -> a -> m Bool

-- | Same as <a>tryPutMVar</a>, but allows to put thunks into an
--   <a>MVar</a>
--   
--   Same as <a>tryPutMVar</a> from <tt>base</tt>, but works in any
--   <a>MonadPrim</a>.
tryPutLazyMVar :: forall a m s. MonadPrim s m => MVar a s -> a -> m Bool

-- | Same as <a>tryPutMVar</a>, but evaluates the argument to NF prior to
--   attempting to write into the <a>MVar</a>
tryPutDeepMVar :: forall a m s. (NFData a, MonadPrim s m) => MVar a s -> a -> m Bool

-- | Write a value into the MVar regardless if it is currently empty or
--   not. If there is a currently a value it will in the MVar it will
--   simply b discarded. However, if there is another thread that is
--   blocked on attempt to write into this MVar, current operation will
--   block on attempt to fill the MVar. Therefore <a>writeMVar</a> is not
--   atomic. Argument is evaluated to WHNF prior to clearing the contents
--   of <a>MVar</a>
writeMVar :: forall a m s. MonadPrim s m => MVar a s -> a -> m ()

-- | Get the value from <a>MVar</a> atomically without affecting its
--   contents. Blocks the current thread if the <a>MVar</a> is currently
--   empty and waits until another thread fills it with a value.
--   
--   Same as <a>readMVar</a> from <tt>base</tt>, but works in any
--   <a>MonadPrim</a>.
readMVar :: forall a m s. MonadPrim s m => MVar a s -> m a

-- | Get the value from <a>MVar</a> atomically without affecting its
--   contents. It does not block and returns the immediately or
--   <a>Nothing</a> if the supplied <a>MVar</a> was empty.
--   
--   Same as <a>tryReadMVar</a> from <tt>base</tt>, but works in any
--   <a>MonadPrim</a>.
tryReadMVar :: forall a m s. MonadPrim s m => MVar a s -> m (Maybe a)

-- | Remove the value from <a>MVar</a> and return it. Blocks the cuurent
--   thread if <a>MVar</a> is empty and waits until antoher thread fills
--   it.
--   
--   Same as <a>takeMVar</a> from <tt>base</tt>, but works in any
--   <a>MonadPrim</a>.
takeMVar :: forall a m s. MonadPrim s m => MVar a s -> m a

-- | Remove the value from <a>MVar</a> and return it immediately without
--   blocking. <a>Nothing</a> is returned if <a>MVar</a> was empty.
--   
--   Same as <a>tryTakeMVar</a> from <tt>base</tt>, but works in any
--   <a>MonadPrim</a>.
tryTakeMVar :: forall a m s. MonadPrim s m => MVar a s -> m (Maybe a)

-- | Remove a value from an <a>MVar</a>, unless it was already empty. It
--   effectively empties the <a>MVar</a> however note that by the time this
--   action returns there is a possibility that another thread might have
--   filled it with a different value.
clearMVar :: forall a m s. MonadPrim s m => MVar a s -> m ()

-- | Replace current value in an <a>MVar</a> with a new one. Supplied value
--   is evaluated to WHNF prior to current value being extracted from the
--   <a>MVar</a>. If <a>MVar</a> is currently empty this operation will
--   block the current thread until it gets filled in another thread.
--   Furthermore it is possible for another thread to fill the <a>MVar</a>
--   after the old value is extracted, but before the new one has a chance
--   to placed inside the <a>MVar</a>, thus blocking current thread once
--   more until another thread empties this <a>MVar</a>. In other words
--   this operation is not atomic.
swapMVar :: forall a m s. MonadPrim s m => MVar a s -> a -> m a

-- | Same as <a>swapMVar</a>, but allows writing thunks into the
--   <a>MVar</a>.
--   
--   Same as <a>swapMVar</a> from <tt>base</tt>, but works in any
--   <a>MonadUnliftPrim</a>.
swapLazyMVar :: forall a m s. MonadPrim s m => MVar a s -> a -> m a

-- | Same as <a>swapMVar</a>, but evaluates the argument value to NF.
swapDeepMVar :: forall a m s. (NFData a, MonadPrim s m) => MVar a s -> a -> m a

-- | Apply an action to the contents of an <a>MVar</a>. Current thread will
--   be blocked if supplied MVar is empty and will wait until another
--   thread fills it with a value. While the action is being appplied other
--   threads should not put anything into the <a>MVar</a> otherwise current
--   thread will get blocked again until another thread empties the
--   <a>MVar</a>. In other words this is not an atomic operation, but it is
--   exception safe, since the contents of <a>MVar</a> are restored
--   regardless of the outcome of supplied action.
--   
--   Same as <a>withMVar</a> from <tt>base</tt>, but works in
--   <a>MonadUnliftPrim</a> with <a>RealWorld</a> state token.
withMVar :: forall a b m. MonadUnliftPrim RW m => MVar a RW -> (a -> m b) -> m b

-- | Same as <a>withMVar</a>, but with supplied action executed with async
--   exceptions masked, but still interruptable.
--   
--   Same as <a>withMVarMasked</a> from <tt>base</tt>, but works in
--   <a>MonadUnliftPrim</a> with <a>RealWorld</a> state token.
withMVarMasked :: forall a b m. MonadUnliftPrim RW m => MVar a RW -> (a -> m b) -> m b

-- | Apply a monadic action to the contents of supplied <a>MVar</a>.
--   Provides the same guarantees as <a>withMVar</a>.
--   
--   Same as <a>modifyMVar_</a> from <tt>base</tt>, but is strict with
--   respect to result of the action and works in <a>MonadUnliftPrim</a>
--   with <a>RealWorld</a> state token.
modifyMVar_ :: forall a m. MonadUnliftPrim RW m => MVar a RW -> (a -> m a) -> m ()

-- | Same as <tt>modifyMVarMAsked_</tt>, but the supplied action has async
--   exceptions masked.
--   
--   Same as <a>modifyMVar</a> from <tt>base</tt>, except that it is strict
--   in the new value and it works in <a>MonadUnliftPrim</a> with
--   <a>RealWorld</a> state token.
modifyMVarMasked_ :: forall a m. MonadUnliftPrim RW m => MVar a RW -> (a -> m a) -> m ()

-- | Same as <a>modifyMVar_</a>, but also returns the original value that
--   was stored in the <a>MVar</a>
modifyFetchOldMVar :: forall a m. MonadUnliftPrim RW m => MVar a RW -> (a -> m a) -> m a

-- | Same as <a>modifyFetchOldMVar</a>, but supplied action will run with
--   async exceptions masked, but still interruptible
modifyFetchOldMVarMasked :: forall a m. MonadUnliftPrim RW m => MVar a RW -> (a -> m a) -> m a

-- | Same as <a>modifyMVar_</a>, but also returns the result of running the
--   supplied action, i.e. the new value that got stored in the
--   <a>MVar</a>.
modifyFetchNewMVar :: forall a m. MonadUnliftPrim RW m => MVar a RW -> (a -> m a) -> m a

-- | Same as <a>modifyFetchNewMVar</a>, but supplied action will run with
--   async exceptions masked, but still interruptible
modifyFetchNewMVarMasked :: forall a m. MonadUnliftPrim RW m => MVar a RW -> (a -> m a) -> m a

-- | Apply a monadic action to the contents of supplied <a>MVar</a>.
--   Provides the same guarantees as <a>withMVar</a>.
--   
--   Same as <a>modifyMVar</a> from <tt>base</tt>, except that it is strict
--   in the new value and it works in <a>MonadUnliftPrim</a> with
--   <a>RealWorld</a> state token.
modifyMVar :: forall a b m. MonadUnliftPrim RW m => MVar a RW -> (a -> m (a, b)) -> m b

-- | Apply a monadic action to the contents of supplied <a>MVar</a>.
--   Provides the same guarantees as <a>withMVar</a>.
--   
--   Same as <a>modifyMVarMasked</a> from <tt>base</tt>, except that it is
--   strict in the new value and it works in <a>MonadUnliftPrim</a> with
--   <a>RealWorld</a> state token.
modifyMVarMasked :: forall a b m. MonadUnliftPrim RW m => MVar a RW -> (a -> m (a, b)) -> m b

-- | Create a <a>Weak</a> pointer associated with the supplied <a>MVar</a>.
--   
--   Same as <a>mkWeakMVar</a> from <tt>base</tt>, but works in any
--   <a>MonadPrim</a> with <a>RealWorld</a> state token.
mkWeakMVar :: forall a b m. MonadUnliftPrim RW m => MVar a RW -> m b -> m (Weak (MVar a RW))

-- | Cast <a>MVar</a> into and the <a>MVar</a> from <tt>base</tt>
toBaseMVar :: MVar a RW -> MVar a

-- | Cast <a>MVar</a> from <tt>base</tt> into <a>MVar</a>.
fromBaseMVar :: MVar a -> MVar a RW
instance GHC.Classes.Eq (Control.Prim.Concurrent.MVar.MVar a s)


module Data.Prim.StableName

-- | An abstract name for an object, that supports equality and hashing.
--   
--   Stable names have the following property:
--   
--   <ul>
--   <li>If <tt>sn1 :: StableName</tt> and <tt>sn2 :: StableName</tt> and
--   <tt>sn1 == sn2</tt> then <tt>sn1</tt> and <tt>sn2</tt> were created by
--   calls to <tt>makeStableName</tt> on the same object.</li>
--   </ul>
--   
--   The reverse is not necessarily true: if two stable names are not
--   equal, then the objects they name may still be equal. Note in
--   particular that <a>makeStableName</a> may return a different
--   <a>StableName</a> after an object is evaluated.
--   
--   Stable Names are similar to Stable Pointers
--   (<a>Foreign.StablePtr</a>), but differ in the following ways:
--   
--   <ul>
--   <li>There is no <tt>freeStableName</tt> operation, unlike
--   <a>Foreign.StablePtr</a>s. Stable names are reclaimed by the runtime
--   system when they are no longer needed.</li>
--   <li>There is no <tt>deRefStableName</tt> operation. You can't get back
--   from a stable name to the original Haskell object. The reason for this
--   is that the existence of a stable name for an object does not
--   guarantee the existence of the object itself; it can still be garbage
--   collected.</li>
--   </ul>
data StableName a
StableName :: StableName# a -> StableName a

-- | Makes a <a>StableName</a> for an arbitrary object. The object passed
--   as the first argument is not evaluated by <a>makeStableName</a>.
makeStableName :: MonadPrim RW m => a -> m (StableName a)

-- | Similar to <a><tt>makeDynamicStableName</tt></a>, but returns
--   <a>StableName</a> <a>Any</a> and is generalized to <a>MonadPrim</a>
makeAnyStableName :: MonadPrim RW m => a -> m (StableName Any)

-- | Convert a <a>StableName</a> to an <a>Int</a>. The <a>Int</a> returned
--   is not necessarily unique; several <a>StableName</a>s may map to the
--   same <a>Int</a> (in practice however, the chances of this are small,
--   so the result of <a>hashStableName</a> makes a good hash key).
hashStableName :: StableName a -> Int

-- | Equality on <a>StableName</a> that does not require that the types of
--   the arguments match.
eqStableName :: StableName a -> StableName b -> Bool
instance GHC.Show.Show (GHC.StableName.StableName a)


module Foreign.Prim
unsafeThawByteArray# :: ByteArray# -> State# s -> (# State# s, MutableByteArray# s #)
mutableByteArrayContents# :: MutableByteArray# s -> Addr#
unsafeThawArrayArray# :: ArrayArray# -> State# s -> (# State# s, MutableArrayArray# s #)
unInt# :: Int -> Int#
unWord# :: Word -> Word#

-- | Same as <a>touch#</a>, except it is not restricted to <a>RealWorld</a>
--   state token.
touch# :: a -> State# s -> State# s

-- | Forward compatible operator that might be introduced in some future
--   ghc version.
--   
--   See: <a>#17760</a>
--   
--   Current version is not as efficient as the version that will be
--   introduced in the future, because it works around the ghc bug by
--   simply preventing inlining and relying on the <a>touch</a> function.
keepAlive# :: a -> (State# s -> (# State# s, r #)) -> State# s -> (# State# s, r #)

-- | Read 8-bit character; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsChar# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsChar# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d

-- | Read 31-bit character; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWideChar# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWideChar# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d

-- | Read address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsAddr# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsAddr# :: MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d

-- | Read stable pointer; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsStablePtr# :: ByteArray# -> Int# -> StablePtr# a

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsStablePtr# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsStablePtr# :: MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d

-- | Read float; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsFloat# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsFloat# :: MutableByteArray# d -> Int# -> Float# -> State# d -> State# d

-- | Read double; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsDouble# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsDouble# :: MutableByteArray# d -> Int# -> Double# -> State# d -> State# d

-- | Read 16-bit int; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsInt16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsInt16# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | Read 32-bit int; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsInt32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsInt32# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | Read 64-bit int; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsInt64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsInt64# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | Read int; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsInt# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsInt# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | Read 16-bit word; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord16# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | Read 32-bit word; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord32# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | Read 64-bit word; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord64# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | Read word; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | Modify the contents of a <tt>MutVar#</tt>, returning the previous
--   contents and the result of applying the given function to the previous
--   contents.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicModifyMutVar_# :: MutVar# d a -> (a -> a) -> State# d -> (# State# d, a, a #)

-- | Modify the contents of a <tt>MutVar#</tt>, returning the previous
--   contents and the result of applying the given function to the previous
--   contents. Note that this isn't strictly speaking the correct type for
--   this function; it should really be <tt>MutVar# s a -&gt; (a -&gt;
--   (a,b)) -&gt; State# s -&gt; (# State# s, a, (a, b) #)</tt>, but we
--   don't know about pairs here.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicModifyMutVar2# :: MutVar# d a -> (a -> c) -> State# d -> (# State# d, a, c #)

-- | <tt>compareByteArrays# src1 src1_ofs src2 src2_ofs n</tt> compares
--   <tt>n</tt> bytes starting at offset <tt>src1_ofs</tt> in the first
--   <tt>ByteArray#</tt> <tt>src1</tt> to the range of <tt>n</tt> bytes
--   (i.e. same length) starting at offset <tt>src2_ofs</tt> of the second
--   <tt>ByteArray#</tt> <tt>src2</tt>. Both arrays must fully contain the
--   specified ranges, but this is not checked. Returns an <tt>Int#</tt>
--   less than, equal to, or greater than zero if the range is found,
--   respectively, to be byte-wise lexicographically less than, to match,
--   or be greater than the second range.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#

-- | Haskell type representing the C <tt>bool</tt> type. <i>(The concrete
--   types of <a>Foreign.C.Types#platform</a> are platform-specific.)</i>
newtype CBool
CBool :: Word8 -> CBool

-- | Determine whether a <tt>ByteArray#</tt> is guaranteed not to move
--   during GC.
isByteArrayPinned# :: ByteArray# -> Int#

-- | Determine whether a <tt>MutableByteArray#</tt> is guaranteed not to
--   move during GC.
isMutableByteArrayPinned# :: MutableByteArray# d -> Int#

-- | Return the number of elements in the array.
getSizeofMutableByteArray# :: MutableByteArray# d -> State# d -> (# State# d, Int# #)
syncXorFetchNewWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncXorFetchNewWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncXorFetchNewInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncXorFetchNewInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncXorFetchOldWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncXorFetchOldWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncXorFetchOldInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncXorFetchOldInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncOrFetchNewWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncOrFetchNewWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncOrFetchNewInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncOrFetchNewInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncOrFetchOldWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncOrFetchOldWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncOrFetchOldInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncOrFetchOldInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncNandFetchNewWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncNandFetchNewWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncNandFetchNewInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncNandFetchNewInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncNandFetchOldWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncNandFetchOldWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncNandFetchOldInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncNandFetchOldInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncAndFetchNewWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncAndFetchNewWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncAndFetchNewInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncAndFetchNewInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncAndFetchOldWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncAndFetchOldWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncAndFetchOldInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncAndFetchOldInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncSubFetchNewWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncSubFetchNewWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncSubFetchNewInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncSubFetchNewInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncSubFetchOldWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncSubFetchOldWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncSubFetchOldInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncSubFetchOldInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncAddFetchNewWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncAddFetchNewWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncAddFetchNewInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncAddFetchNewInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncAddFetchOldWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncAddFetchOldWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncAddFetchOldInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncAddFetchOldInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncCasWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> Word64 -> IO Word64
syncCasWord64AddrIO :: Addr# -> Int# -> Word64 -> Word64 -> IO Word64
syncCasInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> Int64 -> IO Int64
syncCasInt64AddrIO :: Addr# -> Int# -> Int64 -> Int64 -> IO Int64
syncCasWord64BoolArrayIO :: MutableByteArray# s -> Int# -> Word64 -> Word64 -> IO CBool
syncCasWord64BoolAddrIO :: Addr# -> Int# -> Word64 -> Word64 -> IO CBool
syncCasInt64BoolArrayIO :: MutableByteArray# s -> Int# -> Int64 -> Int64 -> IO CBool
syncCasInt64BoolAddrIO :: Addr# -> Int# -> Int64 -> Int64 -> IO CBool
syncXorFetchNewWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncXorFetchNewWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncXorFetchNewIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncXorFetchNewIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncXorFetchOldWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncXorFetchOldWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncXorFetchOldIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncXorFetchOldIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncOrFetchNewWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncOrFetchNewWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncOrFetchNewIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncOrFetchNewIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncOrFetchOldWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncOrFetchOldWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncOrFetchOldIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncOrFetchOldIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncNandFetchNewWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncNandFetchNewWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncNandFetchNewIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncNandFetchNewIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncNandFetchOldWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncNandFetchOldWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncNandFetchOldIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncNandFetchOldIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncAndFetchNewWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncAndFetchNewWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncAndFetchNewIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncAndFetchNewIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncAndFetchOldWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncAndFetchOldWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncAndFetchOldIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncAndFetchOldIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncSubFetchNewWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncSubFetchNewWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncSubFetchNewIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncSubFetchNewIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncSubFetchOldWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncSubFetchOldWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncSubFetchOldIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncSubFetchOldIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncAddFetchNewWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncAddFetchNewWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncAddFetchNewIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncAddFetchNewIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncAddFetchOldWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncAddFetchOldWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncAddFetchOldIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncAddFetchOldIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncCasWordArrayIO :: MutableByteArray# s -> Int# -> Word -> Word -> IO Word
syncCasWordAddrIO :: Addr# -> Int# -> Word -> Word -> IO Word
syncCasIntArrayIO :: MutableByteArray# s -> Int# -> Int -> Int -> IO Int
syncCasIntAddrIO :: Addr# -> Int# -> Int -> Int -> IO Int
syncCasWordBoolArrayIO :: MutableByteArray# s -> Int# -> Word -> Word -> IO CBool
syncCasWordBoolAddrIO :: Addr# -> Int# -> Word -> Word -> IO CBool
syncCasIntBoolArrayIO :: MutableByteArray# s -> Int# -> Int -> Int -> IO CBool
syncCasIntBoolAddrIO :: Addr# -> Int# -> Int -> Int -> IO CBool
syncXorFetchNewWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncXorFetchNewWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncXorFetchNewInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncXorFetchNewInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncXorFetchOldWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncXorFetchOldWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncXorFetchOldInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncXorFetchOldInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncOrFetchNewWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncOrFetchNewWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncOrFetchNewInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncOrFetchNewInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncOrFetchOldWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncOrFetchOldWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncOrFetchOldInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncOrFetchOldInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncNandFetchNewWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncNandFetchNewWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncNandFetchNewInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncNandFetchNewInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncNandFetchOldWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncNandFetchOldWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncNandFetchOldInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncNandFetchOldInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncAndFetchNewWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncAndFetchNewWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncAndFetchNewInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncAndFetchNewInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncAndFetchOldWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncAndFetchOldWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncAndFetchOldInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncAndFetchOldInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncSubFetchNewWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncSubFetchNewWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncSubFetchNewInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncSubFetchNewInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncSubFetchOldWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncSubFetchOldWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncSubFetchOldInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncSubFetchOldInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncAddFetchNewWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncAddFetchNewWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncAddFetchNewInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncAddFetchNewInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncAddFetchOldWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncAddFetchOldWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncAddFetchOldInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncAddFetchOldInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncCasWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> Word32 -> IO Word32
syncCasWord32AddrIO :: Addr# -> Int# -> Word32 -> Word32 -> IO Word32
syncCasInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> Int32 -> IO Int32
syncCasInt32AddrIO :: Addr# -> Int# -> Int32 -> Int32 -> IO Int32
syncCasWord32BoolArrayIO :: MutableByteArray# s -> Int# -> Word32 -> Word32 -> IO CBool
syncCasWord32BoolAddrIO :: Addr# -> Int# -> Word32 -> Word32 -> IO CBool
syncCasInt32BoolArrayIO :: MutableByteArray# s -> Int# -> Int32 -> Int32 -> IO CBool
syncCasInt32BoolAddrIO :: Addr# -> Int# -> Int32 -> Int32 -> IO CBool
syncXorFetchNewWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncXorFetchNewWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncXorFetchNewInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncXorFetchNewInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncXorFetchOldWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncXorFetchOldWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncXorFetchOldInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncXorFetchOldInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncOrFetchNewWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncOrFetchNewWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncOrFetchNewInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncOrFetchNewInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncOrFetchOldWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncOrFetchOldWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncOrFetchOldInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncOrFetchOldInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncNandFetchNewWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncNandFetchNewWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncNandFetchNewInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncNandFetchNewInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncNandFetchOldWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncNandFetchOldWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncNandFetchOldInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncNandFetchOldInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncAndFetchNewWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncAndFetchNewWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncAndFetchNewInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncAndFetchNewInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncAndFetchOldWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncAndFetchOldWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncAndFetchOldInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncAndFetchOldInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncSubFetchNewWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncSubFetchNewWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncSubFetchNewInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncSubFetchNewInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncSubFetchOldWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncSubFetchOldWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncSubFetchOldInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncSubFetchOldInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncAddFetchNewWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncAddFetchNewWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncAddFetchNewInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncAddFetchNewInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncAddFetchOldWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncAddFetchOldWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncAddFetchOldInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncAddFetchOldInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncCasWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> Word16 -> IO Word16
syncCasWord16AddrIO :: Addr# -> Int# -> Word16 -> Word16 -> IO Word16
syncCasInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> Int16 -> IO Int16
syncCasInt16AddrIO :: Addr# -> Int# -> Int16 -> Int16 -> IO Int16
syncCasWord16BoolArrayIO :: MutableByteArray# s -> Int# -> Word16 -> Word16 -> IO CBool
syncCasWord16BoolAddrIO :: Addr# -> Int# -> Word16 -> Word16 -> IO CBool
syncCasInt16BoolArrayIO :: MutableByteArray# s -> Int# -> Int16 -> Int16 -> IO CBool
syncCasInt16BoolAddrIO :: Addr# -> Int# -> Int16 -> Int16 -> IO CBool
syncXorFetchNewWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncXorFetchNewWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncXorFetchNewInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncXorFetchNewInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncXorFetchOldWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncXorFetchOldWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncXorFetchOldInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncXorFetchOldInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncOrFetchNewWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncOrFetchNewWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncOrFetchNewInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncOrFetchNewInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncOrFetchOldWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncOrFetchOldWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncOrFetchOldInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncOrFetchOldInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncNandFetchNewWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncNandFetchNewWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncNandFetchNewInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncNandFetchNewInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncNandFetchOldWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncNandFetchOldWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncNandFetchOldInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncNandFetchOldInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncAndFetchNewWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncAndFetchNewWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncAndFetchNewInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncAndFetchNewInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncAndFetchOldWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncAndFetchOldWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncAndFetchOldInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncAndFetchOldInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncSubFetchNewWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncSubFetchNewWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncSubFetchNewInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncSubFetchNewInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncSubFetchOldWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncSubFetchOldWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncSubFetchOldInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncSubFetchOldInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncAddFetchNewWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncAddFetchNewWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncAddFetchNewInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncAddFetchNewInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncAddFetchOldWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncAddFetchOldWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncAddFetchOldInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncAddFetchOldInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncCasWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> Word8 -> IO Word8
syncCasWord8AddrIO :: Addr# -> Int# -> Word8 -> Word8 -> IO Word8
syncCasInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> Int8 -> IO Int8
syncCasInt8AddrIO :: Addr# -> Int# -> Int8 -> Int8 -> IO Int8
syncCasWord8BoolArrayIO :: MutableByteArray# s -> Int# -> Word8 -> Word8 -> IO CBool
syncCasWord8BoolAddrIO :: Addr# -> Int# -> Word8 -> Word8 -> IO CBool
syncCasInt8BoolArrayIO :: MutableByteArray# s -> Int# -> Int8 -> Int8 -> IO CBool
syncCasInt8BoolAddrIO :: Addr# -> Int# -> Int8 -> Int8 -> IO CBool
syncLockReleaseInt8AddrIO :: Addr# -> Int# -> IO ()
syncLockReleaseInt8ArrayIO :: MutableByteArray# s -> Int# -> IO ()
syncLockTestSetInt8AddrIO :: Addr# -> Int# -> IO Int8
syncLockTestSetInt8ArrayIO :: MutableByteArray# s -> Int# -> IO Int8
syncSynchronize :: IO ()

-- | Helper function for converting casBool IO actions
ioCBoolToBoolBase :: IO CBool -> State# s -> (# State# s, Bool #)

-- | <a>Memory barrier</a>. This will ensure that the cache is fully
--   updated before continuing.
syncSynchronize# :: State# s -> State# s
withMemBarrier# :: (State# s -> (# State# s, a #)) -> State# s -> (# State# s, a #)
withMemBarrier_# :: (State# s -> State# s) -> State# s -> State# s

-- | Because GC is guaranteed not to move unpinned memory during the unsafe
--   FFI call we can compare memory pointers on the C side. Because the
--   addresses cannot change underneath us we can safely guarantee pointer
--   equality for the same pinned or unpinned arrays
isSameByteArray# :: ByteArray# -> ByteArray# -> Int#
isSameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int#

-- | Convert memcmp result into an ordering
toOrdering# :: Int# -> Ordering
fromOrdering# :: Ordering -> Int#
memcmpAddr# :: Addr# -> Int# -> Addr# -> Int# -> Int# -> Int#
memcmpAddrByteArray# :: Addr# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
memcmpByteArray# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
memcmpByteArrayAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> Int# -> Int#
memsetWord8MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word8 -> IO ()
memsetWord8Addr# :: Addr# -> Int# -> Int# -> Word8 -> IO ()
memsetInt8MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int8 -> IO ()
memsetInt8Addr# :: Addr# -> Int# -> Int# -> Int8 -> IO ()
memsetWord16MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word16 -> IO ()
memsetWord16Addr# :: Addr# -> Int# -> Int# -> Word16 -> IO ()
memsetInt16MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int16 -> IO ()
memsetInt16Addr# :: Addr# -> Int# -> Int# -> Int16 -> IO ()
memsetWord32MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word32 -> IO ()
memsetWord32Addr# :: Addr# -> Int# -> Int# -> Word32 -> IO ()
memsetInt32MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int32 -> IO ()
memsetInt32Addr# :: Addr# -> Int# -> Int# -> Int32 -> IO ()
memsetWord64MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word64 -> IO ()
memsetWord64Addr# :: Addr# -> Int# -> Int# -> Word64 -> IO ()
memsetInt64MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int64 -> IO ()
memsetInt64Addr# :: Addr# -> Int# -> Int# -> Int64 -> IO ()
memmoveAddr# :: Addr# -> Int# -> Addr# -> Int# -> Int# -> IO ()
memmoveMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> IO ()
memmoveMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> Int# -> IO ()
memmoveMutableByteArrayFromAddr# :: Addr# -> Int# -> MutableByteArray# s -> Int# -> Int# -> IO ()

-- | Cast a 32bit Word into a Float
word32ToFloat# :: Word# -> Float#

-- | Cast a Float into a 32bit Word
floatToWord32# :: Float# -> Word#

-- | Cast a 64bit Word into a Double
word64ToDouble# :: Word# -> Double#

-- | Cast a Double into a 64bit Word
doubleToWord64# :: Double# -> Word#
getSizeofMutableArray# :: MutableArray# s a -> State# s -> (# State# s, Int# #)
shrinkMutableArray# :: MutableArray# s a -> Int# -> State# s -> State# s
resizeMutableArray# :: MutableArray# s a -> Int# -> a -> State# s -> (# State# s, MutableArray# s a #)

-- | A shorter synonym for the magical <a>RealWorld</a>
type RW = RealWorld

-- | A value of type <tt><a>IO</a> a</tt> is a computation which, when
--   performed, does some I/O before returning a value of type <tt>a</tt>.
--   
--   There is really only one way to "perform" an I/O action: bind it to
--   <tt>Main.main</tt> in your program. When your program is run, the I/O
--   will be performed. It isn't possible to perform I/O from an arbitrary
--   function, unless that function is itself in the <a>IO</a> monad and
--   called at some point, directly or indirectly, from <tt>Main.main</tt>.
--   
--   <a>IO</a> is a monad, so <a>IO</a> actions can be combined using
--   either the do-notation or the <a>&gt;&gt;</a> and <a>&gt;&gt;=</a>
--   operations from the <a>Monad</a> class.
newtype IO a
IO :: (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
unIO :: IO a -> State# RealWorld -> (# State# RealWorld, a #)

-- | Unwrap <a>IO</a> that returns unit
unIO_ :: IO () -> State# RW -> State# RW

-- | The strict <a>ST</a> monad. The <a>ST</a> monad allows for destructive
--   updates, but is escapable (unlike IO). A computation of type
--   <tt><a>ST</a> s a</tt> returns a value of type <tt>a</tt>, and execute
--   in "thread" <tt>s</tt>. The <tt>s</tt> parameter is either
--   
--   <ul>
--   <li>an uninstantiated type variable (inside invocations of
--   <a>runST</a>), or</li>
--   <li><a>RealWorld</a> (inside invocations of <a>stToIO</a>).</li>
--   </ul>
--   
--   It serves to keep the internal states of different invocations of
--   <a>runST</a> separate from each other and from invocations of
--   <a>stToIO</a>.
--   
--   The <a>&gt;&gt;=</a> and <a>&gt;&gt;</a> operations are strict in the
--   state (though not in values stored in the state). For example,
--   
--   <pre>
--   <a>runST</a> (writeSTRef _|_ v &gt;&gt;= f) = _|_
--   </pre>
newtype ST s a
ST :: STRep s a -> ST s a

-- | Unwrap <a>ST</a>
unST :: ST s a -> State# s -> (# State# s, a #)

-- | Unwrap <a>ST</a> that returns unit
unST_ :: ST s () -> State# s -> State# s

-- | A list producer that can be fused with <a>foldr</a>. This function is
--   merely
--   
--   <pre>
--   augment g xs = g (:) xs
--   </pre>
--   
--   but GHC's simplifier will transform an expression of the form
--   <tt><a>foldr</a> k z (<a>augment</a> g xs)</tt>, which may arise after
--   inlining, to <tt>g k (<a>foldr</a> k z xs)</tt>, which avoids
--   producing an intermediate list.
augment :: (forall b. () => (a -> b -> b) -> b -> b) -> [a] -> [a]

-- | A list producer that can be fused with <a>foldr</a>. This function is
--   merely
--   
--   <pre>
--   build g = g (:) []
--   </pre>
--   
--   but GHC's simplifier will transform an expression of the form
--   <tt><a>foldr</a> k z (<a>build</a> g)</tt>, which may arise after
--   inlining, to <tt>g k z</tt>, which avoids producing an intermediate
--   list.
build :: (forall b. () => (a -> b -> b) -> b -> b) -> [a]

-- | The value of <tt>seq a b</tt> is bottom if <tt>a</tt> is bottom, and
--   otherwise equal to <tt>b</tt>. In other words, it evaluates the first
--   argument <tt>a</tt> to weak head normal form (WHNF). <tt>seq</tt> is
--   usually introduced to improve performance by avoiding unneeded
--   laziness.
--   
--   A note on evaluation order: the expression <tt>seq a b</tt> does
--   <i>not</i> guarantee that <tt>a</tt> will be evaluated before
--   <tt>b</tt>. The only guarantee given by <tt>seq</tt> is that the both
--   <tt>a</tt> and <tt>b</tt> will be evaluated before <tt>seq</tt>
--   returns a value. In particular, this means that <tt>b</tt> may be
--   evaluated before <tt>a</tt>. If you need to guarantee a specific order
--   of evaluation, you must use the function <tt>pseq</tt> from the
--   "parallel" package.
seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b
infixr 0 `seq`
realWorld# :: State# RealWorld
void# :: Void#

-- | The function <tt>unsafeCoerce#</tt> 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 <tt>unsafeCoerce#</tt> are supposed to work
--   (i.e. not lead to spurious compile-time or run-time crashes):
--   
--   <ul>
--   <li>Casting any lifted type to <tt>Any</tt></li>
--   <li>Casting <tt>Any</tt> back to the real type</li>
--   <li>Casting an unboxed type to another unboxed type of the same size.
--   (Casting between floating-point and integral types does not work. See
--   the <tt>GHC.Float</tt> module for functions to do work.)</li>
--   <li>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 <tt>Ptr Int</tt> to <tt>Ptr
--   Float</tt>, or <tt>[Int]</tt> to <tt>[Float]</tt> when the list is
--   known to be empty. Also, a <tt>newtype</tt> of a type <tt>T</tt> has
--   the same representation at runtime as <tt>T</tt>.</li>
--   </ul>
--   
--   Other uses of <tt>unsafeCoerce#</tt> are undefined. In particular, you
--   should not use <tt>unsafeCoerce#</tt> to cast a T to an algebraic data
--   type D, unless T is also an algebraic data type. For example, do not
--   cast <tt>Int-&gt;Int</tt> to <tt>Bool</tt>, even if you later cast
--   that <tt>Bool</tt> back to <tt>Int-&gt;Int</tt> before applying it.
--   The reasons have to do with GHC's internal representation details (for
--   the cognoscenti, data values can be entered but function closures
--   cannot). If you want a safe type to cast things to, use <tt>Any</tt>,
--   which is not an algebraic data type.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
unsafeCoerce# :: forall (k0 :: RuntimeRep) (k1 :: RuntimeRep) (a :: TYPE k0) (b :: TYPE k1). a -> b

-- | The null address.
nullAddr# :: Addr#

-- | The <a>lazy</a> function restrains strictness analysis a little. The
--   call <tt>lazy e</tt> means the same as <tt>e</tt>, but <a>lazy</a> has
--   a magical property so far as strictness analysis is concerned: it is
--   lazy in its first argument, even though its semantics is strict. After
--   strictness analysis has run, calls to <a>lazy</a> are inlined to be
--   the identity function.
--   
--   This behaviour is occasionally useful when controlling evaluation
--   order. Notably, <a>lazy</a> is used in the library definition of
--   <a>par</a>:
--   
--   <pre>
--   par :: a -&gt; b -&gt; b
--   par x y = case (par# x) of _ -&gt; lazy y
--   </pre>
--   
--   If <a>lazy</a> were not lazy, <a>par</a> would look strict in
--   <tt>y</tt> which would defeat the whole purpose of <a>par</a>.
--   
--   Like <tt>seq</tt>, the argument of <a>lazy</a> can have an unboxed
--   type.
lazy :: a -> a

-- | The <a>oneShot</a> function can be used to give a hint to the compiler
--   that its argument will be called at most once, which may (or may not)
--   enable certain optimizations. It can be useful to improve the
--   performance of code in continuation passing style.
--   
--   If <a>oneShot</a> 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 <a>oneShot</a> is safe.
--   
--   <a>oneShot</a> is representation polymorphic: the type variables may
--   refer to lifted or unlifted types.
oneShot :: forall (q :: RuntimeRep) (r :: RuntimeRep) (a :: TYPE q) (b :: TYPE r). (a -> b) -> a -> b

-- | Apply a function to a <tt><a>State#</a> <a>RealWorld</a></tt> token.
--   When manually applying a function to <tt>realWorld#</tt>, it is
--   necessary to use <tt>NOINLINE</tt> to prevent semantically undesirable
--   floating. <a>runRW#</a> is inlined, but only very late in compilation
--   after all floating is complete.
runRW# :: forall (r :: RuntimeRep) (o :: TYPE r). (State# RealWorld -> o) -> o
breakpoint :: a -> a
breakpointCond :: Bool -> a -> a

-- | The call <tt>inline f</tt> arranges that <tt>f</tt> is inlined,
--   regardless of its size. More precisely, the call <tt>inline f</tt>
--   rewrites to the right-hand side of <tt>f</tt>'s definition. This
--   allows the programmer to control inlining from a particular call site
--   rather than the definition site of the function (c.f. <tt>INLINE</tt>
--   pragmas).
--   
--   This inlining occurs regardless of the argument to the call or the
--   size of <tt>f</tt>'s definition; it is unconditional. The main caveat
--   is that <tt>f</tt>'s definition must be visible to the compiler; it is
--   therefore recommended to mark the function with an <tt>INLINABLE</tt>
--   pragma at its definition so that GHC guarantees to record its
--   unfolding regardless of size.
--   
--   If no inlining takes place, the <a>inline</a> function expands to the
--   identity function in Phase zero, so its use imposes no overhead.
inline :: a -> a

-- | The <a>groupWith</a> function uses the user supplied function which
--   projects an element out of every list element in order to first sort
--   the input list and then to form groups by equality on these projected
--   elements
groupWith :: Ord b => (a -> b) -> [a] -> [[a]]
magicDict :: a

-- | The function <tt>coerce</tt> 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.
--   
--   This function is runtime-representation polymorphic, but the
--   <tt>RuntimeRep</tt> type argument is marked as <tt>Inferred</tt>,
--   meaning that it is not available for visible type application. This
--   means the typechecker will accept <tt>coerce @Int @Age 42</tt>.
coerce :: forall (k :: RuntimeRep) (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b

-- | The <a>IsList</a> class and its methods are intended to be used in
--   conjunction with the OverloadedLists extension.
class IsList l where {
    
    -- | The <a>Item</a> type function returns the type of items of the
    --   structure <tt>l</tt>.
    type family Item l;
}

-- | The <a>fromList</a> function constructs the structure <tt>l</tt> from
--   the given list of <tt>Item l</tt>
fromList :: IsList l => [Item l] -> l

-- | The <a>fromListN</a> function takes the input list's length as a hint.
--   Its behaviour should be equivalent to <a>fromList</a>. The hint can be
--   used to construct the structure <tt>l</tt> more efficiently compared
--   to <a>fromList</a>. If the given hint does not equal to the input
--   list's length the behaviour of <a>fromListN</a> is not specified.
fromListN :: IsList l => Int -> [Item l] -> l

-- | The <a>toList</a> function extracts a list of <tt>Item l</tt> from the
--   structure <tt>l</tt>. It should satisfy fromList . toList = id.
toList :: IsList l => l -> [Item l]

-- | Witness for an unboxed <tt>Proxy#</tt> value, which has no runtime
--   representation.
proxy# :: forall k (a :: k). Proxy# a

-- | Class for string-like datastructures; used by the overloaded string
--   extension (-XOverloadedStrings in GHC).
class IsString a
fromString :: IsString a => String -> a

-- | An arbitrary machine address assumed to point outside the
--   garbage-collected heap.
data Addr# :: TYPE 'AddrRep
data Array# a :: TYPE 'UnliftedRep
data ByteArray# :: TYPE 'UnliftedRep
data Char# :: TYPE 'WordRep

-- | The character type <a>Char</a> is an enumeration whose values
--   represent Unicode (or equivalently ISO/IEC 10646) code points (i.e.
--   characters, see <a>http://www.unicode.org/</a> for details). This set
--   extends the ISO 8859-1 (Latin-1) character set (the first 256
--   characters), which is itself an extension of the ASCII character set
--   (the first 128 characters). A character literal in Haskell has type
--   <a>Char</a>.
--   
--   To convert a <a>Char</a> to or from the corresponding <a>Int</a> value
--   defined by Unicode, use <a>toEnum</a> and <a>fromEnum</a> from the
--   <a>Enum</a> class respectively (or equivalently <a>ord</a> and
--   <a>chr</a>).
data Char
C# :: Char# -> Char
data Double# :: TYPE 'DoubleRep

-- | Double-precision floating point numbers. It is desirable that this
--   type be at least equal in range and precision to the IEEE
--   double-precision type.
data Double
D# :: Double# -> Double
data Float# :: TYPE 'FloatRep

-- | Single-precision floating point numbers. It is desirable that this
--   type be at least equal in range and precision to the IEEE
--   single-precision type.
data Float
F# :: Float# -> Float
data Int# :: TYPE 'IntRep

-- | A fixed-precision integer type with at least the range <tt>[-2^29 ..
--   2^29-1]</tt>. The exact range for a given implementation can be
--   determined by using <a>minBound</a> and <a>maxBound</a> from the
--   <a>Bounded</a> class.
data Int
I# :: Int# -> Int
data Int8# :: TYPE 'Int8Rep
data Int16# :: TYPE 'Int16Rep
data Int32# :: TYPE 'Int32Rep
data Int64# :: TYPE 'Int64Rep
data Weak# a :: TYPE 'UnliftedRep
data MutableArray# a b :: TYPE 'UnliftedRep
data MutableByteArray# a :: TYPE 'UnliftedRep

-- | A shared mutable variable (<i>not</i> the same as a
--   <tt>MutVar#</tt>!). (Note: in a non-concurrent implementation,
--   <tt>(MVar# a)</tt> can be represented by <tt>(MutVar# (Maybe
--   a))</tt>.)
data MVar# a b :: TYPE 'UnliftedRep

-- | <tt>RealWorld</tt> is deeply magical. It is <i>primitive</i>, but it
--   is not <i>unlifted</i> (hence <tt>ptrArg</tt>). We never manipulate
--   values of type <tt>RealWorld</tt>; it's only used in the type system,
--   to parameterise <tt>State#</tt>.
data RealWorld
data StablePtr# a :: TYPE 'AddrRep

-- | Lifted, heterogeneous equality. By lifted, we mean that it can be
--   bogus (deferred type error). By heterogeneous, the two types
--   <tt>a</tt> and <tt>b</tt> might have different kinds. Because
--   <tt>~~</tt> can appear unexpectedly in error messages to users who do
--   not care about the difference between heterogeneous equality
--   <tt>~~</tt> and homogeneous equality <tt>~</tt>, this is printed as
--   <tt>~</tt> unless <tt>-fprint-equality-relations</tt> is set.
class a ~# b => (a :: k0) ~~ (b :: k1)
data ArrayArray# :: TYPE 'UnliftedRep
data MutableArrayArray# a :: TYPE 'UnliftedRep

-- | <tt>State#</tt> is the primitive, unlifted type of states. It has one
--   type parameter, thus <tt>State# RealWorld</tt>, or <tt>State# s</tt>,
--   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# a :: TYPE 'TupleRep '[] :: [RuntimeRep]
data StableName# a :: TYPE 'UnliftedRep

-- | A <tt>MutVar#</tt> behaves like a single-element mutable array.
data MutVar# a b :: TYPE 'UnliftedRep
data Void# :: TYPE 'TupleRep '[] :: [RuntimeRep]
data Word# :: TYPE 'WordRep

-- | A <a>Word</a> is an unsigned integral type, with the same size as
--   <a>Int</a>.
data Word
W# :: Word# -> Word
data Word8# :: TYPE 'Word8Rep
data Word16# :: TYPE 'Word16Rep
data Word32# :: TYPE 'Word32Rep
data Word64# :: TYPE 'Word64Rep

-- | (In a non-concurrent implementation, this can be a singleton type,
--   whose (unique) value is returned by <tt>myThreadId#</tt>. The other
--   operations can be omitted.)
data ThreadId# :: TYPE 'UnliftedRep

-- | Primitive bytecode type.
data BCO# :: TYPE 'UnliftedRep

-- | A value of type <tt><a>Ptr</a> a</tt> represents a pointer to an
--   object, or an array of objects, which may be marshalled to or from
--   Haskell values of type <tt>a</tt>.
--   
--   The type <tt>a</tt> will often be an instance of class <a>Storable</a>
--   which provides the marshalling operations. However this is not
--   essential, and you can provide your own operations to access the
--   pointer. For example you might write small foreign functions to get or
--   set the fields of a C <tt>struct</tt>.
data Ptr a
Ptr :: Addr# -> Ptr a

-- | A value of type <tt><a>FunPtr</a> a</tt> is a pointer to a function
--   callable from foreign code. The type <tt>a</tt> will normally be a
--   <i>foreign type</i>, a function type with zero or more arguments where
--   
--   <ul>
--   <li>the argument types are <i>marshallable foreign types</i>, i.e.
--   <a>Char</a>, <a>Int</a>, <a>Double</a>, <a>Float</a>, <a>Bool</a>,
--   <a>Int8</a>, <a>Int16</a>, <a>Int32</a>, <a>Int64</a>, <a>Word8</a>,
--   <a>Word16</a>, <a>Word32</a>, <a>Word64</a>, <tt><a>Ptr</a> a</tt>,
--   <tt><a>FunPtr</a> a</tt>, <tt><a>StablePtr</a> a</tt> or a renaming of
--   any of these using <tt>newtype</tt>.</li>
--   <li>the return type is either a marshallable foreign type or has the
--   form <tt><a>IO</a> t</tt> where <tt>t</tt> is a marshallable foreign
--   type or <tt>()</tt>.</li>
--   </ul>
--   
--   A value of type <tt><a>FunPtr</a> a</tt> may be a pointer to a foreign
--   function, either returned by another foreign function or imported with
--   a a static address import like
--   
--   <pre>
--   foreign import ccall "stdlib.h &amp;free"
--     p_free :: FunPtr (Ptr a -&gt; IO ())
--   </pre>
--   
--   or a pointer to a Haskell function created using a <i>wrapper</i> stub
--   declared to produce a <a>FunPtr</a> of the correct type. For example:
--   
--   <pre>
--   type Compare = Int -&gt; Int -&gt; Bool
--   foreign import ccall "wrapper"
--     mkCompare :: Compare -&gt; IO (FunPtr Compare)
--   </pre>
--   
--   Calls to wrapper stubs like <tt>mkCompare</tt> allocate storage, which
--   should be released with <a>freeHaskellFunPtr</a> when no longer
--   required.
--   
--   To convert <a>FunPtr</a> values to corresponding Haskell functions,
--   one can define a <i>dynamic</i> stub for the specific foreign type,
--   e.g.
--   
--   <pre>
--   type IntFunction = CInt -&gt; IO ()
--   foreign import ccall "dynamic"
--     mkFun :: FunPtr IntFunction -&gt; IntFunction
--   </pre>
data FunPtr a
FunPtr :: Addr# -> FunPtr a
data TVar# a b :: TYPE 'UnliftedRep
data Compact# :: TYPE 'UnliftedRep

-- | The kind of constraints, like <tt>Show a</tt>
data Constraint

-- | 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 <a>TYPE</a> is parameterised by
--   <a>RuntimeRep</a>; 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

-- | a SIMD vector type
VecRep :: VecCount -> VecElem -> RuntimeRep

-- | An unboxed tuple of the given reps
TupleRep :: [RuntimeRep] -> RuntimeRep

-- | An unboxed sum of the given reps
SumRep :: [RuntimeRep] -> RuntimeRep

-- | lifted; represented by a pointer
LiftedRep :: RuntimeRep

-- | unlifted; represented by a pointer
UnliftedRep :: RuntimeRep

-- | signed, word-sized value
IntRep :: RuntimeRep

-- | signed, 8-bit value
Int8Rep :: RuntimeRep

-- | signed, 16-bit value
Int16Rep :: RuntimeRep

-- | signed, 32-bit value
Int32Rep :: RuntimeRep

-- | signed, 64-bit value (on 32-bit only)
Int64Rep :: RuntimeRep

-- | unsigned, word-sized value
WordRep :: RuntimeRep

-- | unsigned, 8-bit value
Word8Rep :: RuntimeRep

-- | unsigned, 16-bit value
Word16Rep :: RuntimeRep

-- | unsigned, 32-bit value
Word32Rep :: RuntimeRep

-- | unsigned, 64-bit value (on 32-bit only)
Word64Rep :: RuntimeRep

-- | A pointer, but <i>not</i> to a Haskell value
AddrRep :: RuntimeRep

-- | a 32-bit floating point number
FloatRep :: RuntimeRep

-- | a 64-bit floating point number
DoubleRep :: RuntimeRep

-- | Length of a SIMD vector type
data VecCount
Vec2 :: VecCount
Vec4 :: VecCount
Vec8 :: VecCount
Vec16 :: VecCount
Vec32 :: VecCount
Vec64 :: VecCount

-- | Element of a SIMD vector type
data VecElem
Int8ElemRep :: VecElem
Int16ElemRep :: VecElem
Int32ElemRep :: VecElem
Int64ElemRep :: VecElem
Word8ElemRep :: VecElem
Word16ElemRep :: VecElem
Word32ElemRep :: VecElem
Word64ElemRep :: VecElem
FloatElemRep :: VecElem
DoubleElemRep :: VecElem

-- | <tt>Coercible</tt> is a two-parameter class that has instances for
--   types <tt>a</tt> and <tt>b</tt> 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 <tt>Coercible</tt> is an
--   error.
--   
--   Nevertheless one can pretend that the following three kinds of
--   instances exist. First, as a trivial base-case:
--   
--   <pre>
--   instance Coercible a a
--   </pre>
--   
--   Furthermore, for every type constructor there is an instance that
--   allows to coerce under the type constructor. For example, let
--   <tt>D</tt> be a prototypical type constructor (<tt>data</tt> or
--   <tt>newtype</tt>) with three type arguments, which have roles
--   <tt>nominal</tt>, <tt>representational</tt> resp. <tt>phantom</tt>.
--   Then there is an instance of the form
--   
--   <pre>
--   instance Coercible b b' =&gt; Coercible (D a b c) (D a b' c')
--   </pre>
--   
--   Note that the <tt>nominal</tt> type arguments are equal, the
--   <tt>representational</tt> type arguments can differ, but need to have
--   a <tt>Coercible</tt> instance themself, and the <tt>phantom</tt> type
--   arguments can be changed arbitrarily.
--   
--   The third kind of instance exists for every <tt>newtype NT = MkNT
--   T</tt> and comes in two variants, namely
--   
--   <pre>
--   instance Coercible a T =&gt; Coercible a NT
--   </pre>
--   
--   <pre>
--   instance Coercible T b =&gt; Coercible NT b
--   </pre>
--   
--   This instance is only usable if the constructor <tt>MkNT</tt> is in
--   scope.
--   
--   If, as a library author of a type constructor like <tt>Set a</tt>, you
--   want to prevent a user of your module to write <tt>coerce :: Set T
--   -&gt; Set NT</tt>, you need to set the role of <tt>Set</tt>'s type
--   parameter to <tt>nominal</tt>, by writing
--   
--   <pre>
--   type role Set nominal
--   </pre>
--   
--   For more details about this feature, please refer to <a>Safe
--   Coercions</a> by Joachim Breitner, Richard A. Eisenberg, Simon Peyton
--   Jones and Stephanie Weirich.
class a ~R# b => Coercible (a :: k) (b :: k)

-- | The type constructor <tt>Proxy#</tt> 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 <tt>Proxy#</tt> is
--   not only unboxed, it also has a polymorphic kind, and has no runtime
--   representation, being totally free.
data Proxy# (a :: k) :: TYPE 'TupleRep '[] :: [RuntimeRep]

-- | The type constructor <a>Any</a> is type to which you can unsafely
--   coerce any lifted type, and back. More concretely, for a lifted type
--   <tt>t</tt> and value <tt>x :: t</tt>, -- <tt>unsafeCoerce
--   (unsafeCoerce x :: Any) :: t</tt> is equivalent to <tt>x</tt>.
type family Any :: k
data SmallArray# a :: TYPE 'UnliftedRep
data SmallMutableArray# a b :: TYPE 'UnliftedRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Int8X16# :: TYPE 'VecRep 'Vec16 'Int8ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Int16X8# :: TYPE 'VecRep 'Vec8 'Int16ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Int32X4# :: TYPE 'VecRep 'Vec4 'Int32ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Int64X2# :: TYPE 'VecRep 'Vec2 'Int64ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Int8X32# :: TYPE 'VecRep 'Vec32 'Int8ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Int16X16# :: TYPE 'VecRep 'Vec16 'Int16ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Int32X8# :: TYPE 'VecRep 'Vec8 'Int32ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Int64X4# :: TYPE 'VecRep 'Vec4 'Int64ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Int8X64# :: TYPE 'VecRep 'Vec64 'Int8ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Int16X32# :: TYPE 'VecRep 'Vec32 'Int16ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Int32X16# :: TYPE 'VecRep 'Vec16 'Int32ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Int64X8# :: TYPE 'VecRep 'Vec8 'Int64ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Word8X16# :: TYPE 'VecRep 'Vec16 'Word8ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Word16X8# :: TYPE 'VecRep 'Vec8 'Word16ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Word32X4# :: TYPE 'VecRep 'Vec4 'Word32ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Word64X2# :: TYPE 'VecRep 'Vec2 'Word64ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Word8X32# :: TYPE 'VecRep 'Vec32 'Word8ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Word16X16# :: TYPE 'VecRep 'Vec16 'Word16ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Word32X8# :: TYPE 'VecRep 'Vec8 'Word32ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Word64X4# :: TYPE 'VecRep 'Vec4 'Word64ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Word8X64# :: TYPE 'VecRep 'Vec64 'Word8ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Word16X32# :: TYPE 'VecRep 'Vec32 'Word16ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Word32X16# :: TYPE 'VecRep 'Vec16 'Word32ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data Word64X8# :: TYPE 'VecRep 'Vec8 'Word64ElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data FloatX4# :: TYPE 'VecRep 'Vec4 'FloatElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data DoubleX2# :: TYPE 'VecRep 'Vec2 'DoubleElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data FloatX8# :: TYPE 'VecRep 'Vec8 'FloatElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data DoubleX4# :: TYPE 'VecRep 'Vec4 'DoubleElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data FloatX16# :: TYPE 'VecRep 'Vec16 'FloatElemRep

-- | <b><i>Warning:</i></b> this is only available on LLVM.
data DoubleX8# :: TYPE 'VecRep 'Vec8 'DoubleElemRep
gtChar# :: Char# -> Char# -> Int#
geChar# :: Char# -> Char# -> Int#
eqChar# :: Char# -> Char# -> Int#
neChar# :: Char# -> Char# -> Int#
ltChar# :: Char# -> Char# -> Int#
leChar# :: Char# -> Char# -> Int#
ord# :: Char# -> Int#
(+#) :: Int# -> Int# -> Int#
infixl 6 +#
(-#) :: Int# -> Int# -> Int#
infixl 6 -#

-- | Low word of signed integer multiply.
(*#) :: Int# -> Int# -> Int#
infixl 7 *#

-- | Return non-zero if there is any possibility that the upper word of a
--   signed integer multiply might contain useful information. Return zero
--   only if you are completely sure that no overflow can occur. On a
--   32-bit platform, the recommended implementation is to do a 32 x 32
--   -&gt; 64 signed multiply, and subtract result[63:32] from (result[31]
--   &gt;&gt;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
--   <tt>(*) :: Integer -&gt; Integer -&gt; Integer</tt> will be poor.
mulIntMayOflo# :: Int# -> Int# -> Int#

-- | Rounds towards zero. The behavior is undefined if the second argument
--   is zero.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
quotInt# :: Int# -> Int# -> Int#

-- | Satisfies <tt>(quotInt# x y) *# y +# (remInt# x y) == x</tt>. The
--   behavior is undefined if the second argument is zero.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
remInt# :: Int# -> Int# -> Int#

-- | Rounds towards zero.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
quotRemInt# :: Int# -> Int# -> (# Int#, Int# #)

-- | Bitwise "and".
andI# :: Int# -> Int# -> Int#

-- | Bitwise "or".
orI# :: Int# -> Int# -> Int#

-- | Bitwise "xor".
xorI# :: Int# -> Int# -> Int#

-- | Bitwise "not", also known as the binary complement.
notI# :: Int# -> Int#

-- | Unary negation. Since the negative <tt>Int#</tt> range extends one
--   further than the positive range, <tt>negateInt#</tt> of the most
--   negative number is an identity operation. This way,
--   <tt>negateInt#</tt> is always its own inverse.
negateInt# :: Int# -> Int#

-- | Add signed integers reporting overflow. First member of result is the
--   sum truncated to an <tt>Int#</tt>; second member is zero if the true
--   sum fits in an <tt>Int#</tt>, nonzero if overflow occurred (the sum is
--   either too large or too small to fit in an <tt>Int#</tt>).
addIntC# :: Int# -> Int# -> (# Int#, Int# #)

-- | Subtract signed integers reporting overflow. First member of result is
--   the difference truncated to an <tt>Int#</tt>; second member is zero if
--   the true difference fits in an <tt>Int#</tt>, nonzero if overflow
--   occurred (the difference is either too large or too small to fit in an
--   <tt>Int#</tt>).
subIntC# :: Int# -> Int# -> (# Int#, Int# #)
(>#) :: 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#
infix 4 <=#
chr# :: Int# -> Char#
int2Word# :: Int# -> Word#
int2Float# :: Int# -> Float#
int2Double# :: Int# -> Double#
word2Float# :: Word# -> Float#
word2Double# :: Word# -> Double#

-- | Shift left. Result undefined if shift amount is not in the range 0 to
--   word size - 1 inclusive.
uncheckedIShiftL# :: Int# -> Int# -> Int#

-- | Shift right arithmetic. Result undefined if shift amount is not in the
--   range 0 to word size - 1 inclusive.
uncheckedIShiftRA# :: Int# -> Int# -> Int#

-- | Shift right logical. Result undefined if shift amount is not in the
--   range 0 to word size - 1 inclusive.
uncheckedIShiftRL# :: Int# -> Int# -> Int#
extendInt8# :: Int8# -> Int#
narrowInt8# :: Int# -> Int8#
negateInt8# :: Int8# -> Int8#
plusInt8# :: Int8# -> Int8# -> Int8#
subInt8# :: Int8# -> Int8# -> Int8#
timesInt8# :: Int8# -> Int8# -> Int8#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
quotInt8# :: Int8# -> Int8# -> Int8#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
remInt8# :: Int8# -> Int8# -> Int8#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
quotRemInt8# :: Int8# -> Int8# -> (# Int8#, Int8# #)
eqInt8# :: Int8# -> Int8# -> Int#
geInt8# :: Int8# -> Int8# -> Int#
gtInt8# :: Int8# -> Int8# -> Int#
leInt8# :: Int8# -> Int8# -> Int#
ltInt8# :: Int8# -> Int8# -> Int#
neInt8# :: Int8# -> Int8# -> Int#
extendWord8# :: Word8# -> Word#
narrowWord8# :: Word# -> Word8#
notWord8# :: Word8# -> Word8#
plusWord8# :: Word8# -> Word8# -> Word8#
subWord8# :: Word8# -> Word8# -> Word8#
timesWord8# :: Word8# -> Word8# -> Word8#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
quotWord8# :: Word8# -> Word8# -> Word8#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
remWord8# :: Word8# -> Word8# -> Word8#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
quotRemWord8# :: Word8# -> Word8# -> (# Word8#, Word8# #)
eqWord8# :: Word8# -> Word8# -> Int#
geWord8# :: Word8# -> Word8# -> Int#
gtWord8# :: Word8# -> Word8# -> Int#
leWord8# :: Word8# -> Word8# -> Int#
ltWord8# :: Word8# -> Word8# -> Int#
neWord8# :: Word8# -> Word8# -> Int#
extendInt16# :: Int16# -> Int#
narrowInt16# :: Int# -> Int16#
negateInt16# :: Int16# -> Int16#
plusInt16# :: Int16# -> Int16# -> Int16#
subInt16# :: Int16# -> Int16# -> Int16#
timesInt16# :: Int16# -> Int16# -> Int16#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
quotInt16# :: Int16# -> Int16# -> Int16#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
remInt16# :: Int16# -> Int16# -> Int16#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
quotRemInt16# :: Int16# -> Int16# -> (# Int16#, Int16# #)
eqInt16# :: Int16# -> Int16# -> Int#
geInt16# :: Int16# -> Int16# -> Int#
gtInt16# :: Int16# -> Int16# -> Int#
leInt16# :: Int16# -> Int16# -> Int#
ltInt16# :: Int16# -> Int16# -> Int#
neInt16# :: Int16# -> Int16# -> Int#
extendWord16# :: Word16# -> Word#
narrowWord16# :: Word# -> Word16#
notWord16# :: Word16# -> Word16#
plusWord16# :: Word16# -> Word16# -> Word16#
subWord16# :: Word16# -> Word16# -> Word16#
timesWord16# :: Word16# -> Word16# -> Word16#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
quotWord16# :: Word16# -> Word16# -> Word16#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
remWord16# :: Word16# -> Word16# -> Word16#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
quotRemWord16# :: Word16# -> Word16# -> (# Word16#, Word16# #)
eqWord16# :: Word16# -> Word16# -> Int#
geWord16# :: Word16# -> Word16# -> Int#
gtWord16# :: Word16# -> Word16# -> Int#
leWord16# :: Word16# -> Word16# -> Int#
ltWord16# :: Word16# -> Word16# -> Int#
neWord16# :: Word16# -> Word16# -> Int#
plusWord# :: Word# -> Word# -> Word#

-- | Add unsigned integers reporting overflow. The first element of the
--   pair is the result. The second element is the carry flag, which is
--   nonzero on overflow. See also <tt>plusWord2#</tt>.
addWordC# :: Word# -> Word# -> (# Word#, Int# #)

-- | Subtract unsigned integers reporting overflow. The first element of
--   the pair is the result. The second element is the carry flag, which is
--   nonzero on overflow.
subWordC# :: Word# -> Word# -> (# Word#, Int# #)

-- | Add unsigned integers, with the high part (carry) in the first
--   component of the returned pair and the low part in the second
--   component of the pair. See also <tt>addWordC#</tt>.
plusWord2# :: Word# -> Word# -> (# Word#, Word# #)
minusWord# :: Word# -> Word# -> Word#
timesWord# :: Word# -> Word# -> Word#
timesWord2# :: Word# -> Word# -> (# Word#, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
quotWord# :: Word# -> Word# -> Word#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
remWord# :: Word# -> Word# -> Word#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
quotRemWord# :: Word# -> Word# -> (# Word#, Word# #)

-- | Takes high word of dividend, then low word of dividend, then divisor.
--   Requires that high word &lt; divisor.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#, Word# #)
and# :: Word# -> Word# -> Word#
or# :: Word# -> Word# -> Word#
xor# :: Word# -> Word# -> Word#
not# :: Word# -> Word#

-- | Shift left logical. Result undefined if shift amount is not in the
--   range 0 to word size - 1 inclusive.
uncheckedShiftL# :: Word# -> Int# -> Word#

-- | Shift right logical. Result undefined if shift amount is not in the
--   range 0 to word size - 1 inclusive.
uncheckedShiftRL# :: Word# -> Int# -> Word#
word2Int# :: Word# -> Int#
gtWord# :: Word# -> Word# -> Int#
geWord# :: Word# -> Word# -> Int#
eqWord# :: Word# -> Word# -> Int#
neWord# :: Word# -> Word# -> Int#
ltWord# :: Word# -> Word# -> Int#
leWord# :: Word# -> Word# -> Int#

-- | Count the number of set bits in the lower 8 bits of a word.
popCnt8# :: Word# -> Word#

-- | Count the number of set bits in the lower 16 bits of a word.
popCnt16# :: Word# -> Word#

-- | Count the number of set bits in the lower 32 bits of a word.
popCnt32# :: Word# -> Word#

-- | Count the number of set bits in a 64-bit word.
popCnt64# :: Word# -> Word#

-- | Count the number of set bits in a word.
popCnt# :: Word# -> Word#

-- | Deposit bits to lower 8 bits of a word at locations specified by a
--   mask.
pdep8# :: Word# -> Word# -> Word#

-- | Deposit bits to lower 16 bits of a word at locations specified by a
--   mask.
pdep16# :: Word# -> Word# -> Word#

-- | Deposit bits to lower 32 bits of a word at locations specified by a
--   mask.
pdep32# :: Word# -> Word# -> Word#

-- | Deposit bits to a word at locations specified by a mask.
pdep64# :: Word# -> Word# -> Word#

-- | Deposit bits to a word at locations specified by a mask.
pdep# :: Word# -> Word# -> Word#

-- | Extract bits from lower 8 bits of a word at locations specified by a
--   mask.
pext8# :: Word# -> Word# -> Word#

-- | Extract bits from lower 16 bits of a word at locations specified by a
--   mask.
pext16# :: Word# -> Word# -> Word#

-- | Extract bits from lower 32 bits of a word at locations specified by a
--   mask.
pext32# :: Word# -> Word# -> Word#

-- | Extract bits from a word at locations specified by a mask.
pext64# :: Word# -> Word# -> Word#

-- | Extract bits from a word at locations specified by a mask.
pext# :: Word# -> Word# -> Word#

-- | Count leading zeros in the lower 8 bits of a word.
clz8# :: Word# -> Word#

-- | Count leading zeros in the lower 16 bits of a word.
clz16# :: Word# -> Word#

-- | Count leading zeros in the lower 32 bits of a word.
clz32# :: Word# -> Word#

-- | Count leading zeros in a 64-bit word.
clz64# :: Word# -> Word#

-- | Count leading zeros in a word.
clz# :: Word# -> Word#

-- | Count trailing zeros in the lower 8 bits of a word.
ctz8# :: Word# -> Word#

-- | Count trailing zeros in the lower 16 bits of a word.
ctz16# :: Word# -> Word#

-- | Count trailing zeros in the lower 32 bits of a word.
ctz32# :: Word# -> Word#

-- | Count trailing zeros in a 64-bit word.
ctz64# :: Word# -> Word#

-- | Count trailing zeros in a word.
ctz# :: Word# -> Word#

-- | Swap bytes in the lower 16 bits of a word. The higher bytes are
--   undefined.
byteSwap16# :: Word# -> Word#

-- | Swap bytes in the lower 32 bits of a word. The higher bytes are
--   undefined.
byteSwap32# :: Word# -> Word#

-- | Swap bytes in a 64 bits of a word.
byteSwap64# :: Word# -> Word#

-- | Swap bytes in a word.
byteSwap# :: Word# -> Word#

-- | Reverse the order of the bits in a 8-bit word.
bitReverse8# :: Word# -> Word#

-- | Reverse the order of the bits in a 16-bit word.
bitReverse16# :: Word# -> Word#

-- | Reverse the order of the bits in a 32-bit word.
bitReverse32# :: Word# -> Word#

-- | Reverse the order of the bits in a 64-bit word.
bitReverse64# :: Word# -> Word#

-- | Reverse the order of the bits in a word.
bitReverse# :: Word# -> Word#
narrow8Int# :: Int# -> Int#
narrow16Int# :: Int# -> Int#
narrow32Int# :: Int# -> Int#
narrow8Word# :: Word# -> Word#
narrow16Word# :: Word# -> Word#
narrow32Word# :: Word# -> Word#
(>##) :: Double# -> Double# -> Int#
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# -> Double#
infixl 6 +##
(-##) :: Double# -> Double# -> Double#
infixl 6 -##
(*##) :: Double# -> Double# -> Double#
infixl 7 *##

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
(/##) :: Double# -> Double# -> Double#
infixl 7 /##
negateDouble# :: Double# -> Double#
fabsDouble# :: Double# -> Double#

-- | Truncates a <tt>Double#</tt> value to the nearest <tt>Int#</tt>.
--   Results are undefined if the truncation if truncation yields a value
--   outside the range of <tt>Int#</tt>.
double2Int# :: Double# -> Int#
double2Float# :: Double# -> Float#
expDouble# :: Double# -> Double#
expm1Double# :: Double# -> Double#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
logDouble# :: Double# -> Double#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
log1pDouble# :: Double# -> Double#
sqrtDouble# :: Double# -> Double#
sinDouble# :: Double# -> Double#
cosDouble# :: Double# -> Double#
tanDouble# :: Double# -> Double#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
asinDouble# :: Double# -> Double#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
acosDouble# :: Double# -> Double#
atanDouble# :: Double# -> Double#
sinhDouble# :: Double# -> Double#
coshDouble# :: Double# -> Double#
tanhDouble# :: Double# -> Double#
asinhDouble# :: Double# -> Double#
acoshDouble# :: Double# -> Double#
atanhDouble# :: Double# -> Double#

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

-- | Decode <tt>Double#</tt> into mantissa and base-2 exponent.
decodeDouble_Int64# :: Double# -> (# Int#, Int# #)
gtFloat# :: Float# -> Float# -> Int#
geFloat# :: Float# -> Float# -> Int#
eqFloat# :: Float# -> Float# -> Int#
neFloat# :: Float# -> Float# -> Int#
ltFloat# :: Float# -> Float# -> Int#
leFloat# :: Float# -> Float# -> Int#
plusFloat# :: Float# -> Float# -> Float#
minusFloat# :: Float# -> Float# -> Float#
timesFloat# :: Float# -> Float# -> Float#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
divideFloat# :: Float# -> Float# -> Float#
negateFloat# :: Float# -> Float#
fabsFloat# :: Float# -> Float#

-- | Truncates a <tt>Float#</tt> value to the nearest <tt>Int#</tt>.
--   Results are undefined if the truncation if truncation yields a value
--   outside the range of <tt>Int#</tt>.
float2Int# :: Float# -> Int#
expFloat# :: Float# -> Float#
expm1Float# :: Float# -> Float#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
logFloat# :: Float# -> Float#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
log1pFloat# :: Float# -> Float#
sqrtFloat# :: Float# -> Float#
sinFloat# :: Float# -> Float#
cosFloat# :: Float# -> Float#
tanFloat# :: Float# -> Float#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
asinFloat# :: Float# -> Float#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
acosFloat# :: Float# -> Float#
atanFloat# :: Float# -> Float#
sinhFloat# :: Float# -> Float#
coshFloat# :: Float# -> Float#
tanhFloat# :: Float# -> Float#
asinhFloat# :: Float# -> Float#
acoshFloat# :: Float# -> Float#
atanhFloat# :: Float# -> Float#
powerFloat# :: Float# -> Float# -> Float#
float2Double# :: Float# -> Double#

-- | Convert to integers. First <tt>Int#</tt> in result is the mantissa;
--   second is the exponent.
decodeFloat_Int# :: Float# -> (# Int#, Int# #)

-- | 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# d -> (# State# d, MutableArray# d a #)
sameMutableArray# :: MutableArray# d a -> MutableArray# d a -> Int#

-- | Read from specified index of mutable array. Result is not yet
--   evaluated.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readArray# :: MutableArray# d a -> Int# -> State# d -> (# State# d, a #)

-- | Write to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeArray# :: MutableArray# d a -> Int# -> a -> State# d -> State# d

-- | Return the number of elements in the array.
sizeofArray# :: Array# a -> Int#

-- | Return the number of elements in the array.
sizeofMutableArray# :: MutableArray# d a -> Int#

-- | Read from the specified index of an immutable array. The result is
--   packaged into an unboxed unary tuple; the result itself is not yet
--   evaluated. Pattern matching on the tuple forces the indexing of the
--   array to happen but does not evaluate the element itself. Evaluating
--   the thunk prevents additional thunks from building up on the heap.
--   Avoiding these thunks, in turn, reduces references to the argument
--   array, allowing it to be garbage collected more promptly.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexArray# :: Array# a -> Int# -> (# a #)

-- | Make a mutable array immutable, without copying.
unsafeFreezeArray# :: MutableArray# d a -> State# d -> (# State# d, Array# a #)

-- | Make an immutable array mutable, without copying.
unsafeThawArray# :: Array# a -> State# d -> (# State# d, MutableArray# d a #)

-- | 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyArray# :: Array# a -> Int# -> MutableArray# d a -> Int# -> Int# -> State# d -> State# d

-- | Given a source array, an offset into the source array, a destination
--   array, an offset into the destination array, and a number of elements
--   to copy, copy the elements from the source array to the destination
--   array. Both arrays must fully contain the specified ranges, but this
--   is not checked. In the case where the source and destination are the
--   same array the source and destination regions may overlap.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyMutableArray# :: MutableArray# d a -> Int# -> MutableArray# d a -> Int# -> Int# -> State# d -> State# d

-- | 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
cloneArray# :: Array# a -> Int# -> Int# -> Array# a

-- | Given a source array, an offset into the source array, and a number of
--   elements to copy, create a new array with the elements from the source
--   array. The provided array must fully contain the specified range, but
--   this is not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
cloneMutableArray# :: MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)

-- | Given a source array, an offset into the source array, and a number of
--   elements to copy, create a new array with the elements from the source
--   array. The provided array must fully contain the specified range, but
--   this is not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
freezeArray# :: MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, Array# a #)

-- | Given a source array, an offset into the source array, and a number of
--   elements to copy, create a new array with the elements from the source
--   array. The provided array must fully contain the specified range, but
--   this is not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
thawArray# :: Array# a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)

-- | Given an array, an offset, the expected old value, and the new value,
--   perform an atomic compare and swap (i.e. write the new value if the
--   current value and the old value are the same pointer). Returns 0 if
--   the swap succeeds and 1 if it fails. Additionally, returns the element
--   at the offset after the operation completes. This means that on a
--   success the new value is returned, and on a failure the actual old
--   value (not the expected one) is returned. Implies a full memory
--   barrier. The use of a pointer equality on a lifted value makes this
--   function harder to use correctly than <tt>casIntArray#</tt>. All of
--   the difficulties of using <tt>reallyUnsafePtrEquality#</tt> correctly
--   apply to <tt>casArray#</tt> as well.
casArray# :: MutableArray# d a -> Int# -> a -> a -> State# d -> (# State# d, Int#, 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# d -> (# State# d, SmallMutableArray# d a #)
sameSmallMutableArray# :: SmallMutableArray# d a -> SmallMutableArray# d a -> Int#

-- | Shrink mutable array to new specified size, in the specified state
--   thread. The new size argument must be less than or equal to the
--   current size as reported by <tt>sizeofSmallMutableArray#</tt>.
shrinkSmallMutableArray# :: SmallMutableArray# d a -> Int# -> State# d -> State# d

-- | Read from specified index of mutable array. Result is not yet
--   evaluated.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readSmallArray# :: SmallMutableArray# d a -> Int# -> State# d -> (# State# d, a #)

-- | Write to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeSmallArray# :: SmallMutableArray# d a -> Int# -> a -> State# d -> State# d

-- | Return the number of elements in the array.
sizeofSmallArray# :: SmallArray# a -> Int#

-- | Return the number of elements in the array. Note that this is
--   deprecated as it is unsafe in the presence of resize operations on the
--   same byte array.
sizeofSmallMutableArray# :: SmallMutableArray# d a -> Int#

-- | Return the number of elements in the array.
getSizeofSmallMutableArray# :: SmallMutableArray# d a -> State# d -> (# State# d, Int# #)

-- | Read from specified index of immutable array. Result is packaged into
--   an unboxed singleton; the result itself is not yet evaluated.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexSmallArray# :: SmallArray# a -> Int# -> (# a #)

-- | Make a mutable array immutable, without copying.
unsafeFreezeSmallArray# :: SmallMutableArray# d a -> State# d -> (# State# d, SmallArray# a #)

-- | Make an immutable array mutable, without copying.
unsafeThawSmallArray# :: SmallArray# a -> State# d -> (# State# d, SmallMutableArray# d a #)

-- | 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# d a -> Int# -> Int# -> State# d -> State# d

-- | Given a source array, an offset into the source array, a destination
--   array, an offset into the destination array, and a number of elements
--   to copy, copy the elements from the source array to the destination
--   array. The source and destination arrays can refer to the same array.
--   Both arrays must fully contain the specified ranges, but this is not
--   checked. The regions are allowed to overlap, although this is only
--   possible when the same array is provided as both the source and the
--   destination.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copySmallMutableArray# :: SmallMutableArray# d a -> Int# -> SmallMutableArray# d a -> Int# -> Int# -> State# d -> State# d

-- | 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a

-- | Given a source array, an offset into the source array, and a number of
--   elements to copy, create a new array with the elements from the source
--   array. The provided array must fully contain the specified range, but
--   this is not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
cloneSmallMutableArray# :: SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)

-- | Given a source array, an offset into the source array, and a number of
--   elements to copy, create a new array with the elements from the source
--   array. The provided array must fully contain the specified range, but
--   this is not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
freezeSmallArray# :: SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallArray# a #)

-- | Given a source array, an offset into the source array, and a number of
--   elements to copy, create a new array with the elements from the source
--   array. The provided array must fully contain the specified range, but
--   this is not checked.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
thawSmallArray# :: SmallArray# a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)

-- | Unsafe, machine-level atomic compare and swap on an element within an
--   array. See the documentation of <tt>casArray#</tt>.
casSmallArray# :: SmallMutableArray# d a -> Int# -> a -> a -> State# d -> (# State# d, Int#, a #)

-- | Create a new mutable byte array of specified size (in bytes), in the
--   specified state thread.
newByteArray# :: Int# -> State# d -> (# State# d, MutableByteArray# d #)

-- | Create a mutable byte array that the GC guarantees not to move.
newPinnedByteArray# :: Int# -> State# d -> (# State# d, MutableByteArray# d #)

-- | Create a mutable byte array, aligned by the specified amount, that the
--   GC guarantees not to move.
newAlignedPinnedByteArray# :: Int# -> Int# -> State# d -> (# State# d, MutableByteArray# d #)

-- | Determine whether a <tt>MutableByteArray#</tt> is guaranteed not to
--   move during GC.
isMutableByteArrayPinned# :: MutableByteArray# d -> Int#

-- | Determine whether a <tt>ByteArray#</tt> is guaranteed not to move
--   during GC.
isByteArrayPinned# :: ByteArray# -> Int#

-- | Intended for use with pinned arrays; otherwise very unsafe!
byteArrayContents# :: ByteArray# -> Addr#
sameMutableByteArray# :: MutableByteArray# d -> MutableByteArray# d -> Int#

-- | 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
--   <tt>sizeofMutableByteArray#</tt>.
shrinkMutableByteArray# :: MutableByteArray# d -> Int# -> State# d -> State# d

-- | Resize (unpinned) mutable byte array to new specified size (in bytes).
--   The returned <tt>MutableByteArray#</tt> is either the original
--   <tt>MutableByteArray#</tt> resized in-place or, if not possible, a
--   newly allocated (unpinned) <tt>MutableByteArray#</tt> (with the
--   original content copied over).
--   
--   To avoid undefined behaviour, the original <tt>MutableByteArray#</tt>
--   shall not be accessed anymore after a <tt>resizeMutableByteArray#</tt>
--   has been performed. Moreover, no reference to the old one should be
--   kept in order to allow garbage collection of the original
--   <tt>MutableByteArray#</tt> in case a new <tt>MutableByteArray#</tt>
--   had to be allocated.
resizeMutableByteArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, MutableByteArray# d #)

-- | Make a mutable byte array immutable, without copying.
unsafeFreezeByteArray# :: MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)

-- | Return the size of the array in bytes.
sizeofByteArray# :: ByteArray# -> Int#

-- | Return the size of the array in bytes. Note that this is deprecated as
--   it is unsafe in the presence of resize operations on the same byte
--   array.
sizeofMutableByteArray# :: MutableByteArray# d -> Int#

-- | Return the number of elements in the array.
getSizeofMutableByteArray# :: MutableByteArray# d -> State# d -> (# State# d, Int# #)

-- | Read 8-bit character; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexCharArray# :: ByteArray# -> Int# -> Char#

-- | Read 31-bit character; offset in 4-byte words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWideCharArray# :: ByteArray# -> Int# -> Char#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexIntArray# :: ByteArray# -> Int# -> Int#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWordArray# :: ByteArray# -> Int# -> Word#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexAddrArray# :: ByteArray# -> Int# -> Addr#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexFloatArray# :: ByteArray# -> Int# -> Float#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexDoubleArray# :: ByteArray# -> Int# -> Double#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a

-- | Read 8-bit integer; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexInt8Array# :: ByteArray# -> Int# -> Int#

-- | Read 16-bit integer; offset in 16-bit words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexInt16Array# :: ByteArray# -> Int# -> Int#

-- | Read 32-bit integer; offset in 32-bit words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexInt32Array# :: ByteArray# -> Int# -> Int#

-- | Read 64-bit integer; offset in 64-bit words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexInt64Array# :: ByteArray# -> Int# -> Int#

-- | Read 8-bit word; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8Array# :: ByteArray# -> Int# -> Word#

-- | Read 16-bit word; offset in 16-bit words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord16Array# :: ByteArray# -> Int# -> Word#

-- | Read 32-bit word; offset in 32-bit words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord32Array# :: ByteArray# -> Int# -> Word#

-- | Read 64-bit word; offset in 64-bit words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord64Array# :: ByteArray# -> Int# -> Word#

-- | Read 8-bit character; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char#

-- | Read 31-bit character; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char#

-- | Read address; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr#

-- | Read float; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float#

-- | Read double; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double#

-- | Read stable pointer; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsStablePtr# :: ByteArray# -> Int# -> StablePtr# a

-- | Read 16-bit int; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int#

-- | Read 32-bit int; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int#

-- | Read 64-bit int; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int#

-- | Read int; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int#

-- | Read 16-bit word; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word#

-- | Read 32-bit word; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word#

-- | Read 64-bit word; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word#

-- | Read word; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word#

-- | Read 8-bit character; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readCharArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)

-- | Read 31-bit character; offset in 4-byte words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWideCharArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)

-- | Read integer; offset in machine words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readIntArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | Read word; offset in machine words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWordArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readAddrArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readStablePtrArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsChar# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWideChar# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsAddr# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsFloat# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsDouble# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsStablePtr# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsInt16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsInt32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsInt64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsInt# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8ArrayAsWord# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)

-- | Write 8-bit character; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeCharArray# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d

-- | Write 31-bit character; offset in 4-byte words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWideCharArray# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWordArray# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeAddrArray# :: MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatArray# :: MutableByteArray# d -> Int# -> Float# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleArray# :: MutableByteArray# d -> Int# -> Double# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeStablePtrArray# :: MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8Array# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16Array# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32Array# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64Array# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8Array# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16Array# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32Array# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64Array# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsChar# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWideChar# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsAddr# :: MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsFloat# :: MutableByteArray# d -> Int# -> Float# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsDouble# :: MutableByteArray# d -> Int# -> Double# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsStablePtr# :: MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsInt16# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsInt32# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsInt64# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsInt# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord16# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord32# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord64# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8ArrayAsWord# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d

-- | <tt>compareByteArrays# src1 src1_ofs src2 src2_ofs n</tt> compares
--   <tt>n</tt> bytes starting at offset <tt>src1_ofs</tt> in the first
--   <tt>ByteArray#</tt> <tt>src1</tt> to the range of <tt>n</tt> bytes
--   (i.e. same length) starting at offset <tt>src2_ofs</tt> of the second
--   <tt>ByteArray#</tt> <tt>src2</tt>. Both arrays must fully contain the
--   specified ranges, but this is not checked. Returns an <tt>Int#</tt>
--   less than, equal to, or greater than zero if the range is found,
--   respectively, to be byte-wise lexicographically less than, to match,
--   or be greater than the second range.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#

-- | <tt>copyByteArray# src src_ofs dst dst_ofs n</tt> copies the range
--   starting at offset <tt>src_ofs</tt> of length <tt>n</tt> from the
--   <tt>ByteArray#</tt> <tt>src</tt> to the <tt>MutableByteArray#</tt>
--   <tt>dst</tt> starting at offset <tt>dst_ofs</tt>. 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | 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. The regions are allowed to
--   overlap, although this is only possible when the same array is
--   provided as both the source and the destination.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyMutableByteArray# :: MutableByteArray# d -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# d -> State# d

-- | 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyMutableByteArrayToAddr# :: MutableByteArray# d -> Int# -> Addr# -> Int# -> State# d -> State# d

-- | 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyAddrToByteArray# :: Addr# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | <tt>setByteArray# ba off len c</tt> sets the byte range <tt>[off,
--   off+len]</tt> of the <tt>MutableByteArray#</tt> to the byte
--   <tt>c</tt>.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
setByteArray# :: MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> State# d

-- | Given an array and an offset in machine words, read an element. The
--   index is assumed to be in bounds. Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicReadIntArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)

-- | Given an array and an offset in machine words, write an element. The
--   index is assumed to be in bounds. Implies a full memory barrier.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicWriteIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d

-- | Given an array, an offset in machine words, 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
casIntArray# :: MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> (# State# d, Int# #)

-- | Given an array, and offset in machine words, 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchAddIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)

-- | Given an array, and offset in machine words, 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchSubIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)

-- | Given an array, and offset in machine words, 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchAndIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)

-- | Given an array, and offset in machine words, 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchNandIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)

-- | Given an array, and offset in machine words, 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchOrIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)

-- | Given an array, and offset in machine words, 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
fetchXorIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)

-- | 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# d -> (# State# d, MutableArrayArray# d #)
sameMutableArrayArray# :: MutableArrayArray# d -> MutableArrayArray# d -> Int#

-- | Make a mutable array of arrays immutable, without copying.
unsafeFreezeArrayArray# :: MutableArrayArray# d -> State# d -> (# State# d, ArrayArray# #)

-- | Return the number of elements in the array.
sizeofArrayArray# :: ArrayArray# -> Int#

-- | Return the number of elements in the array.
sizeofMutableArrayArray# :: MutableArrayArray# d -> Int#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readByteArrayArray# :: MutableArrayArray# d -> Int# -> State# d -> (# State# d, ByteArray# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readMutableByteArrayArray# :: MutableArrayArray# d -> Int# -> State# d -> (# State# d, MutableByteArray# d #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readArrayArrayArray# :: MutableArrayArray# d -> Int# -> State# d -> (# State# d, ArrayArray# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readMutableArrayArrayArray# :: MutableArrayArray# d -> Int# -> State# d -> (# State# d, MutableArrayArray# d #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeByteArrayArray# :: MutableArrayArray# d -> Int# -> ByteArray# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeMutableByteArrayArray# :: MutableArrayArray# d -> Int# -> MutableByteArray# d -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeArrayArrayArray# :: MutableArrayArray# d -> Int# -> ArrayArray# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeMutableArrayArrayArray# :: MutableArrayArray# d -> Int# -> MutableArrayArray# d -> State# d -> State# d

-- | 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.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# d -> Int# -> Int# -> State# d -> State# d

-- | Copy a range of the first MutableArrayArray# to the specified region
--   in the second MutableArrayArray#. Both arrays must fully contain the
--   specified ranges, but this is not checked. The regions are allowed to
--   overlap, although this is only possible when the same array is
--   provided as both the source and the destination.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
copyMutableArrayArray# :: MutableArrayArray# d -> Int# -> MutableArrayArray# d -> Int# -> Int# -> State# d -> State# d
plusAddr# :: Addr# -> Int# -> Addr#

-- | Result is meaningless if two <tt>Addr#</tt>s are so far apart that
--   their difference doesn't fit in an <tt>Int#</tt>.
minusAddr# :: Addr# -> Addr# -> Int#

-- | Return the remainder when the <tt>Addr#</tt> arg, treated like an
--   <tt>Int#</tt>, is divided by the <tt>Int#</tt> arg.
remAddr# :: Addr# -> Int# -> Int#

-- | Coerce directly from address to int.
addr2Int# :: Addr# -> Int#

-- | Coerce directly from int to address.
int2Addr# :: Int# -> Addr#
gtAddr# :: Addr# -> Addr# -> Int#
geAddr# :: Addr# -> Addr# -> Int#
eqAddr# :: Addr# -> Addr# -> Int#
neAddr# :: Addr# -> Addr# -> Int#
ltAddr# :: Addr# -> Addr# -> Int#
leAddr# :: Addr# -> Addr# -> Int#

-- | Reads 8-bit character; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexCharOffAddr# :: Addr# -> Int# -> Char#

-- | Reads 31-bit character; offset in 4-byte words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWideCharOffAddr# :: Addr# -> Int# -> Char#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexIntOffAddr# :: Addr# -> Int# -> Int#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWordOffAddr# :: Addr# -> Int# -> Word#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexAddrOffAddr# :: Addr# -> Int# -> Addr#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexFloatOffAddr# :: Addr# -> Int# -> Float#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexDoubleOffAddr# :: Addr# -> Int# -> Double#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexInt8OffAddr# :: Addr# -> Int# -> Int#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexInt16OffAddr# :: Addr# -> Int# -> Int#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexInt32OffAddr# :: Addr# -> Int# -> Int#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexInt64OffAddr# :: Addr# -> Int# -> Int#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord8OffAddr# :: Addr# -> Int# -> Word#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord16OffAddr# :: Addr# -> Int# -> Word#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord32OffAddr# :: Addr# -> Int# -> Word#

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
indexWord64OffAddr# :: Addr# -> Int# -> Word#

-- | Reads 8-bit character; offset in bytes.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readCharOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Char# #)

-- | Reads 31-bit character; offset in 4-byte words.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWideCharOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Char# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readIntOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWordOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readAddrOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Addr# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readFloatOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Float# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readDoubleOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Double# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readStablePtrOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readInt64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
readWord64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d

-- | <b><i>Warning:</i></b> this can fail with an unchecked exception.
writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d

-- | Create <tt>MutVar#</tt> with specified initial value in specified
--   state thread.
newMutVar# :: a -> State# d -> (# State# d, MutVar# d a #)

-- | Read contents of <tt>MutVar#</tt>. Result is not yet evaluated.
readMutVar# :: MutVar# d a -> State# d -> (# State# d, a #)

-- | Write contents of <tt>MutVar#</tt>.
writeMutVar# :: MutVar# d a -> a -> State# d -> State# d
sameMutVar# :: MutVar# d a -> MutVar# d a -> Int#

-- | Modify the contents of a <tt>MutVar#</tt>, returning the previous
--   contents and the result of applying the given function to the previous
--   contents. Note that this isn't strictly speaking the correct type for
--   this function; it should really be <tt>MutVar# s a -&gt; (a -&gt;
--   (a,b)) -&gt; State# s -&gt; (# State# s, a, (a, b) #)</tt>, but we
--   don't know about pairs here.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicModifyMutVar2# :: MutVar# d a -> (a -> c) -> State# d -> (# State# d, a, c #)

-- | Modify the contents of a <tt>MutVar#</tt>, returning the previous
--   contents and the result of applying the given function to the previous
--   contents.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
atomicModifyMutVar_# :: MutVar# d a -> (a -> a) -> State# d -> (# State# d, a, a #)
casMutVar# :: MutVar# d a -> a -> a -> State# d -> (# State# d, Int#, a #)
catch# :: (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
raise# :: forall b (q :: RuntimeRep) (a :: TYPE q). b -> a
raiseIO# :: a -> State# RealWorld -> (# State# RealWorld, b #)
maskAsyncExceptions# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
maskUninterruptible# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
unmaskAsyncExceptions# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
getMaskingState# :: State# RealWorld -> (# State# RealWorld, Int# #)
atomically# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
retry# :: State# RealWorld -> (# State# RealWorld, a #)
catchRetry# :: (State# RealWorld -> (# State# RealWorld, a #)) -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
catchSTM# :: (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)

-- | Create a new <tt>TVar#</tt> holding a specified initial value.
newTVar# :: a -> State# d -> (# State# d, TVar# d a #)

-- | Read contents of <tt>TVar#</tt>. Result is not yet evaluated.
readTVar# :: TVar# d a -> State# d -> (# State# d, a #)

-- | Read contents of <tt>TVar#</tt> outside an STM transaction
readTVarIO# :: TVar# d a -> State# d -> (# State# d, a #)

-- | Write contents of <tt>TVar#</tt>.
writeTVar# :: TVar# d a -> a -> State# d -> State# d
sameTVar# :: TVar# d a -> TVar# d a -> Int#

-- | Create new <tt>MVar#</tt>; initially empty.
newMVar# :: State# d -> (# State# d, MVar# d a #)

-- | If <tt>MVar#</tt> is empty, block until it becomes full. Then remove
--   and return its contents, and set it empty.
takeMVar# :: MVar# d a -> State# d -> (# State# d, a #)

-- | If <tt>MVar#</tt> is empty, immediately return with integer 0 and
--   value undefined. Otherwise, return with integer 1 and contents of
--   <tt>MVar#</tt>, and set <tt>MVar#</tt> empty.
tryTakeMVar# :: MVar# d a -> State# d -> (# State# d, Int#, a #)

-- | If <tt>MVar#</tt> is full, block until it becomes empty. Then store
--   value arg as its new contents.
putMVar# :: MVar# d a -> a -> State# d -> State# d

-- | If <tt>MVar#</tt> is full, immediately return with integer 0.
--   Otherwise, store value arg as <tt>MVar#</tt>'s new contents, and
--   return with integer 1.
tryPutMVar# :: MVar# d a -> a -> State# d -> (# State# d, Int# #)

-- | If <tt>MVar#</tt> is empty, block until it becomes full. Then read its
--   contents without modifying the MVar, without possibility of
--   intervention from other threads.
readMVar# :: MVar# d a -> State# d -> (# State# d, a #)

-- | If <tt>MVar#</tt> is empty, immediately return with integer 0 and
--   value undefined. Otherwise, return with integer 1 and contents of
--   <tt>MVar#</tt>.
tryReadMVar# :: MVar# d a -> State# d -> (# State# d, Int#, a #)
sameMVar# :: MVar# d a -> MVar# d a -> Int#

-- | Return 1 if <tt>MVar#</tt> is empty; 0 otherwise.
isEmptyMVar# :: MVar# d a -> State# d -> (# State# d, Int# #)

-- | Sleep specified number of microseconds.
delay# :: Int# -> State# d -> State# d

-- | Block until input is available on specified file descriptor.
waitRead# :: Int# -> State# d -> State# d

-- | Block until output is possible on specified file descriptor.
waitWrite# :: Int# -> State# d -> State# d
fork# :: a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
forkOn# :: Int# -> a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
killThread# :: ThreadId# -> a -> State# RealWorld -> State# RealWorld
yield# :: State# RealWorld -> State# RealWorld
myThreadId# :: State# RealWorld -> (# State# RealWorld, ThreadId# #)
labelThread# :: ThreadId# -> Addr# -> State# RealWorld -> State# RealWorld
isCurrentThreadBound# :: State# RealWorld -> (# State# RealWorld, Int# #)
noDuplicate# :: State# d -> State# d
threadStatus# :: ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, Int#, Int# #)

-- | <tt>mkWeak# k v finalizer s</tt> creates a weak reference to value
--   <tt>k</tt>, with an associated reference to some value <tt>v</tt>. If
--   <tt>k</tt> is still alive then <tt>v</tt> can be retrieved using
--   <tt>deRefWeak#</tt>. Note that the type of <tt>k</tt> must be
--   represented by a pointer (i.e. of kind <tt>TYPE 'LiftedRep</tt> or
--   <tt>TYPE 'UnliftedRep</tt>).
mkWeak# :: forall (q :: RuntimeRep) (a :: TYPE q) b c. a -> b -> (State# RealWorld -> (# State# RealWorld, c #)) -> State# RealWorld -> (# State# RealWorld, Weak# b #)
mkWeakNoFinalizer# :: forall (q :: RuntimeRep) (a :: TYPE q) b. a -> b -> State# RealWorld -> (# State# RealWorld, Weak# b #)

-- | <tt>addCFinalizerToWeak# fptr ptr flag eptr w</tt> attaches a C
--   function pointer <tt>fptr</tt> to a weak pointer <tt>w</tt> as a
--   finalizer. If <tt>flag</tt> is zero, <tt>fptr</tt> will be called with
--   one argument, <tt>ptr</tt>. Otherwise, it will be called with two
--   arguments, <tt>eptr</tt> and <tt>ptr</tt>.
--   <tt>addCFinalizerToWeak#</tt> returns 1 on success, or 0 if <tt>w</tt>
--   is already dead.
addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# RealWorld -> (# State# RealWorld, Int# #)
deRefWeak# :: Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, a #)

-- | 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 <tt>Int#</tt> and a (possibly invalid) finalization
--   action. An <tt>Int#</tt> of <tt>1</tt> indicates that the finalizer is
--   valid. The return value <tt>b</tt> from the finalizer should be
--   ignored.
finalizeWeak# :: Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, State# RealWorld -> (# State# RealWorld, b #) #)
makeStablePtr# :: a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)
deRefStablePtr# :: StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)
eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int#
makeStableName# :: a -> State# RealWorld -> (# State# RealWorld, StableName# a #)
eqStableName# :: StableName# a -> StableName# b -> Int#
stableNameToInt# :: StableName# a -> Int#

-- | Create a new CNF with a single compact block. The argument is the
--   capacity of the compact block (in bytes, not words). The capacity is
--   rounded up to a multiple of the allocator block size and is capped to
--   one mega block.
compactNew# :: Word# -> State# RealWorld -> (# State# RealWorld, Compact# #)

-- | Set the new allocation size of the CNF. This value (in bytes)
--   determines the capacity of each compact block in the CNF. It does not
--   retroactively affect existing compact blocks in the CNF.
compactResize# :: Compact# -> Word# -> State# RealWorld -> State# RealWorld

-- | Returns 1# if the object is contained in the CNF, 0# otherwise.
compactContains# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, Int# #)

-- | Returns 1# if the object is in any CNF at all, 0# otherwise.
compactContainsAny# :: a -> State# RealWorld -> (# State# RealWorld, Int# #)

-- | Returns the address and the utilized size (in bytes) of the first
--   compact block of a CNF.
compactGetFirstBlock# :: Compact# -> State# RealWorld -> (# State# RealWorld, Addr#, Word# #)

-- | Given a CNF and the address of one its compact blocks, returns the
--   next compact block and its utilized size, or <tt>nullAddr#</tt> if the
--   argument was the last compact block in the CNF.
compactGetNextBlock# :: Compact# -> Addr# -> State# RealWorld -> (# State# RealWorld, Addr#, Word# #)

-- | Attempt to allocate a compact block with the capacity (in bytes) given
--   by the first argument. The <tt>Addr#</tt> is a pointer to previous
--   compact block of the CNF or <tt>nullAddr#</tt> to create a new CNF
--   with a single compact block.
--   
--   The resulting block is not known to the GC until
--   <tt>compactFixupPointers#</tt> is called on it, and care must be taken
--   so that the address does not escape or memory will be leaked.
compactAllocateBlock# :: Word# -> Addr# -> State# RealWorld -> (# State# RealWorld, Addr# #)

-- | Given the pointer to the first block of a CNF and the address of the
--   root object in the old address space, fix up the internal pointers
--   inside the CNF to account for a different position in memory than when
--   it was serialized. This method must be called exactly once after
--   importing a serialized CNF. It returns the new CNF and the new
--   adjusted root address.
compactFixupPointers# :: Addr# -> Addr# -> State# RealWorld -> (# State# RealWorld, Compact#, Addr# #)

-- | Recursively add a closure and its transitive closure to a
--   <tt>Compact#</tt> (a CNF), evaluating any unevaluated components at
--   the same time. Note: <tt>compactAdd#</tt> is not thread-safe, so only
--   one thread may call <tt>compactAdd#</tt> with a particular
--   <tt>Compact#</tt> at any given time. The primop does not enforce any
--   mutual exclusion; the caller is expected to arrange this.
compactAdd# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, a #)

-- | Like <tt>compactAdd#</tt>, but retains sharing and cycles during
--   compaction.
compactAddWithSharing# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, a #)

-- | Return the total capacity (in bytes) of all the compact blocks in the
--   CNF.
compactSize# :: Compact# -> State# RealWorld -> (# State# RealWorld, Word# #)

-- | Returns <tt>1#</tt> if the given pointers are equal and <tt>0#</tt>
--   otherwise.
--   
--   <b><i>Warning:</i></b> this can fail with an unchecked exception.
reallyUnsafePtrEquality# :: a -> a -> Int#
par# :: a -> Int#
spark# :: a -> State# d -> (# State# d, a #)
seq# :: a -> State# d -> (# State# d, a #)
getSpark# :: State# d -> (# State# d, Int#, a #)

-- | Returns the number of sparks in the local spark pool.
numSparks# :: State# d -> (# State# d, Int# #)
dataToTag# :: a -> Int#
tagToEnum# :: Int# -> a

-- | Convert an <tt>Addr#</tt> to a followable Any type.
addrToAny# :: Addr# -> (# a #)

-- | Retrieve the address of any Haskell value. This is essentially an
--   <tt>unsafeCoerce#</tt>, but if implemented as such the core lint pass
--   complains and fails to compile. As a primop, it is opaque to core/stg,
--   and only appears in cmm (where the copy propagation pass will get rid
--   of it). Note that "a" must be a value, not a thunk! It's too late for
--   strictness analysis to enforce this, so you're on your own to
--   guarantee this. Also note that <tt>Addr#</tt> is not a GC pointer - up
--   to you to guarantee that it does not become a dangling pointer
--   immediately after you get it.
anyToAddr# :: a -> State# RealWorld -> (# State# RealWorld, Addr# #)

-- | Wrap a BCO in a <tt>AP_UPD</tt> thunk which will be updated with the
--   value of the BCO when evaluated.
mkApUpd0# :: BCO# -> (# a #)

-- | <tt>newBCO# instrs lits ptrs arity bitmap</tt> creates a new bytecode
--   object. The resulting object encodes a function of the given arity
--   with the instructions encoded in <tt>instrs</tt>, and a static
--   reference table usage bitmap given by <tt>bitmap</tt>.
newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# d -> (# State# d, BCO# #)

-- | <tt>unpackClosure# closure</tt> copies the closure and pointers in the
--   payload of the given closure into two new arrays, and returns a
--   pointer to the first word of the closure's info table, a non-pointer
--   array for the raw bytes of the closure, and a pointer array for the
--   pointers in the payload.
unpackClosure# :: a -> (# Addr#, ByteArray#, Array# b #)

-- | <tt>closureSize# closure</tt> returns the size of the given closure in
--   machine words.
closureSize# :: a -> Int#
getApStackVal# :: a -> Int# -> (# Int#, b #)
getCCSOf# :: a -> State# d -> (# State# d, Addr# #)

-- | Returns the current <tt>CostCentreStack</tt> (value is <tt>NULL</tt>
--   if not profiling). Takes a dummy argument which can be used to avoid
--   the call to <tt>getCurrentCCS#</tt> being floated out by the
--   simplifier, which would result in an uninformative stack ("CAF").
getCurrentCCS# :: a -> State# d -> (# State# d, Addr# #)

-- | 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# d -> (# State# d, a #)) -> State# d -> (# State# d, a #)

-- | 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 <tt>.eventlog</tt> file, or to
--   stderr, depending on the runtime RTS flags.
traceEvent# :: Addr# -> State# d -> State# d

-- | Emits an event via the RTS tracing framework. The contents of the
--   event is the binary object passed as the first argument with the the
--   given length passed as the second argument. The event will be emitted
--   to the <tt>.eventlog</tt> file.
traceBinaryEvent# :: Addr# -> Int# -> State# d -> State# d

-- | Emits a marker event via the RTS tracing framework. The contents of
--   the event is the zero-terminated byte string passed as the first
--   argument. The event will be emitted either to the <tt>.eventlog</tt>
--   file, or to stderr, depending on the runtime RTS flags.
traceMarker# :: Addr# -> State# d -> State# d

-- | Sets the allocation counter for the current thread to the given value.
setThreadAllocationCounter# :: Int# -> State# RealWorld -> State# RealWorld

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastInt8X16# :: Int# -> Int8X16#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastInt16X8# :: Int# -> Int16X8#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastInt32X4# :: Int# -> Int32X4#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastInt64X2# :: Int# -> Int64X2#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastInt8X32# :: Int# -> Int8X32#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastInt16X16# :: Int# -> Int16X16#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastInt32X8# :: Int# -> Int32X8#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastInt64X4# :: Int# -> Int64X4#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastInt8X64# :: Int# -> Int8X64#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastInt16X32# :: Int# -> Int16X32#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastInt32X16# :: Int# -> Int32X16#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastInt64X8# :: Int# -> Int64X8#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastWord8X16# :: Word# -> Word8X16#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastWord16X8# :: Word# -> Word16X8#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastWord32X4# :: Word# -> Word32X4#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastWord64X2# :: Word# -> Word64X2#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastWord8X32# :: Word# -> Word8X32#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastWord16X16# :: Word# -> Word16X16#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastWord32X8# :: Word# -> Word32X8#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastWord64X4# :: Word# -> Word64X4#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastWord8X64# :: Word# -> Word8X64#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastWord16X32# :: Word# -> Word16X32#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastWord32X16# :: Word# -> Word32X16#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastWord64X8# :: Word# -> Word64X8#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastFloatX4# :: Float# -> FloatX4#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastDoubleX2# :: Double# -> DoubleX2#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastFloatX8# :: Float# -> FloatX8#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastDoubleX4# :: Double# -> DoubleX4#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastFloatX16# :: Float# -> FloatX16#

-- | Broadcast a scalar to all elements of a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
broadcastDoubleX8# :: Double# -> DoubleX8#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packInt8X16# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X16#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packInt16X8# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X8#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packInt32X4# :: (# Int#, Int#, Int#, Int# #) -> Int32X4#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packInt64X2# :: (# Int#, Int# #) -> Int64X2#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packInt8X32# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X32#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packInt16X16# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X16#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packInt32X8# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int32X8#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packInt64X4# :: (# Int#, Int#, Int#, Int# #) -> Int64X4#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packInt8X64# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X64#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packInt16X32# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X32#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packInt32X16# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int32X16#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packInt64X8# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int64X8#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packWord8X16# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word8X16#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packWord16X8# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word16X8#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packWord32X4# :: (# Word#, Word#, Word#, Word# #) -> Word32X4#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packWord64X2# :: (# Word#, Word# #) -> Word64X2#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packWord8X32# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word8X32#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packWord16X16# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word16X16#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packWord32X8# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word32X8#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packWord64X4# :: (# Word#, Word#, Word#, Word# #) -> Word64X4#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packWord8X64# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word8X64#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packWord16X32# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word16X32#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packWord32X16# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word32X16#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packWord64X8# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word64X8#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packFloatX4# :: (# Float#, Float#, Float#, Float# #) -> FloatX4#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packDoubleX2# :: (# Double#, Double# #) -> DoubleX2#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packFloatX8# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX8#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packDoubleX4# :: (# Double#, Double#, Double#, Double# #) -> DoubleX4#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packFloatX16# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX16#

-- | Pack the elements of an unboxed tuple into a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
packDoubleX8# :: (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #) -> DoubleX8#

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackInt8X16# :: Int8X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackInt16X8# :: Int16X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackInt32X4# :: Int32X4# -> (# Int#, Int#, Int#, Int# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackInt64X2# :: Int64X2# -> (# Int#, Int# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackInt8X32# :: Int8X32# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackInt16X16# :: Int16X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackInt32X8# :: Int32X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackInt64X4# :: Int64X4# -> (# Int#, Int#, Int#, Int# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackInt8X64# :: Int8X64# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackInt16X32# :: Int16X32# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackInt32X16# :: Int32X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackInt64X8# :: Int64X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackWord8X16# :: Word8X16# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackWord16X8# :: Word16X8# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackWord32X4# :: Word32X4# -> (# Word#, Word#, Word#, Word# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackWord64X2# :: Word64X2# -> (# Word#, Word# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackWord8X32# :: Word8X32# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackWord16X16# :: Word16X16# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackWord32X8# :: Word32X8# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackWord64X4# :: Word64X4# -> (# Word#, Word#, Word#, Word# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackWord8X64# :: Word8X64# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackWord16X32# :: Word16X32# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackWord32X16# :: Word32X16# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackWord64X8# :: Word64X8# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackFloatX4# :: FloatX4# -> (# Float#, Float#, Float#, Float# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackDoubleX2# :: DoubleX2# -> (# Double#, Double# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackFloatX8# :: FloatX8# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackDoubleX4# :: DoubleX4# -> (# Double#, Double#, Double#, Double# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackFloatX16# :: FloatX16# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)

-- | Unpack the elements of a vector into an unboxed tuple. #
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
unpackDoubleX8# :: DoubleX8# -> (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #)

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertInt8X16# :: Int8X16# -> Int# -> Int# -> Int8X16#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertInt16X8# :: Int16X8# -> Int# -> Int# -> Int16X8#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertInt32X4# :: Int32X4# -> Int# -> Int# -> Int32X4#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertInt64X2# :: Int64X2# -> Int# -> Int# -> Int64X2#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertInt8X32# :: Int8X32# -> Int# -> Int# -> Int8X32#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertInt16X16# :: Int16X16# -> Int# -> Int# -> Int16X16#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertInt32X8# :: Int32X8# -> Int# -> Int# -> Int32X8#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertInt64X4# :: Int64X4# -> Int# -> Int# -> Int64X4#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertInt8X64# :: Int8X64# -> Int# -> Int# -> Int8X64#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertInt16X32# :: Int16X32# -> Int# -> Int# -> Int16X32#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertInt32X16# :: Int32X16# -> Int# -> Int# -> Int32X16#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertInt64X8# :: Int64X8# -> Int# -> Int# -> Int64X8#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertWord8X16# :: Word8X16# -> Word# -> Int# -> Word8X16#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertWord16X8# :: Word16X8# -> Word# -> Int# -> Word16X8#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertWord32X4# :: Word32X4# -> Word# -> Int# -> Word32X4#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertWord64X2# :: Word64X2# -> Word# -> Int# -> Word64X2#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertWord8X32# :: Word8X32# -> Word# -> Int# -> Word8X32#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertWord16X16# :: Word16X16# -> Word# -> Int# -> Word16X16#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertWord32X8# :: Word32X8# -> Word# -> Int# -> Word32X8#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertWord64X4# :: Word64X4# -> Word# -> Int# -> Word64X4#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertWord8X64# :: Word8X64# -> Word# -> Int# -> Word8X64#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertWord16X32# :: Word16X32# -> Word# -> Int# -> Word16X32#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertWord32X16# :: Word32X16# -> Word# -> Int# -> Word32X16#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertWord64X8# :: Word64X8# -> Word# -> Int# -> Word64X8#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16#

-- | Insert a scalar at the given position in a vector.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#

-- | Add two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#

-- | Subtract two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#

-- | Multiply two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#

-- | Divide two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#

-- | Divide two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#

-- | Divide two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#

-- | Divide two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#

-- | Divide two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#

-- | Divide two vectors element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#

-- | Rounds towards zero element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#

-- | Satisfies <tt>(quot# x y) times# y plus# (rem# x y) == x</tt>.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateInt8X16# :: Int8X16# -> Int8X16#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateInt16X8# :: Int16X8# -> Int16X8#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateInt32X4# :: Int32X4# -> Int32X4#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateInt64X2# :: Int64X2# -> Int64X2#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateInt8X32# :: Int8X32# -> Int8X32#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateInt16X16# :: Int16X16# -> Int16X16#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateInt32X8# :: Int32X8# -> Int32X8#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateInt64X4# :: Int64X4# -> Int64X4#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateInt8X64# :: Int8X64# -> Int8X64#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateInt16X32# :: Int16X32# -> Int16X32#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateInt32X16# :: Int32X16# -> Int32X16#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateInt64X8# :: Int64X8# -> Int64X8#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateFloatX4# :: FloatX4# -> FloatX4#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateDoubleX2# :: DoubleX2# -> DoubleX2#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateFloatX8# :: FloatX8# -> FloatX8#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateDoubleX4# :: DoubleX4# -> DoubleX4#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateFloatX16# :: FloatX16# -> FloatX16#

-- | Negate element-wise.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM.
negateDoubleX8# :: DoubleX8# -> DoubleX8#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16#

-- | Read a vector from specified index of immutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8#

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt8X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt16X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt32X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt64X2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt8X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt16X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt32X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt64X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt8X64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt16X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt32X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt64X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord8X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord16X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord32X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord64X2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord8X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord16X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord32X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord64X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord8X64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord16X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord32X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord64X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readFloatX4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readDoubleX2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readFloatX8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readDoubleX4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readFloatX16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)

-- | Read a vector from specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readDoubleX8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt8X16Array# :: MutableByteArray# d -> Int# -> Int8X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt16X8Array# :: MutableByteArray# d -> Int# -> Int16X8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt32X4Array# :: MutableByteArray# d -> Int# -> Int32X4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt64X2Array# :: MutableByteArray# d -> Int# -> Int64X2# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt8X32Array# :: MutableByteArray# d -> Int# -> Int8X32# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt16X16Array# :: MutableByteArray# d -> Int# -> Int16X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt32X8Array# :: MutableByteArray# d -> Int# -> Int32X8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt64X4Array# :: MutableByteArray# d -> Int# -> Int64X4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt8X64Array# :: MutableByteArray# d -> Int# -> Int8X64# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt16X32Array# :: MutableByteArray# d -> Int# -> Int16X32# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt32X16Array# :: MutableByteArray# d -> Int# -> Int32X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt64X8Array# :: MutableByteArray# d -> Int# -> Int64X8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord8X16Array# :: MutableByteArray# d -> Int# -> Word8X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord16X8Array# :: MutableByteArray# d -> Int# -> Word16X8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord32X4Array# :: MutableByteArray# d -> Int# -> Word32X4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord64X2Array# :: MutableByteArray# d -> Int# -> Word64X2# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord8X32Array# :: MutableByteArray# d -> Int# -> Word8X32# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord16X16Array# :: MutableByteArray# d -> Int# -> Word16X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord32X8Array# :: MutableByteArray# d -> Int# -> Word32X8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord64X4Array# :: MutableByteArray# d -> Int# -> Word64X4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord8X64Array# :: MutableByteArray# d -> Int# -> Word8X64# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord16X32Array# :: MutableByteArray# d -> Int# -> Word16X32# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord32X16Array# :: MutableByteArray# d -> Int# -> Word32X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord64X8Array# :: MutableByteArray# d -> Int# -> Word64X8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeFloatX4Array# :: MutableByteArray# d -> Int# -> FloatX4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeDoubleX2Array# :: MutableByteArray# d -> Int# -> DoubleX2# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeFloatX8Array# :: MutableByteArray# d -> Int# -> FloatX8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeDoubleX4Array# :: MutableByteArray# d -> Int# -> DoubleX4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeFloatX16Array# :: MutableByteArray# d -> Int# -> FloatX16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeDoubleX8Array# :: MutableByteArray# d -> Int# -> DoubleX8# -> State# d -> State# d

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8#

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt8X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt16X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt32X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt64X2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt8X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt16X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt32X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt64X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt8X64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt16X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt32X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt64X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord8X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord16X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord32X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord64X2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord8X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord16X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord32X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord64X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord8X64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord16X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord32X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord64X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readFloatX4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readDoubleX2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readFloatX8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readDoubleX4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readFloatX16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)

-- | Reads vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readDoubleX8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -> State# d -> State# d

-- | Write vector; offset in bytes.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -> State# d -> State# d

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16#

-- | Read a vector from specified index of immutable array of scalars;
--   offset is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8#

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt8ArrayAsInt8X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt16ArrayAsInt16X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt32ArrayAsInt32X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt64ArrayAsInt64X2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt8ArrayAsInt8X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt16ArrayAsInt16X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt32ArrayAsInt32X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt64ArrayAsInt64X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt8ArrayAsInt8X64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt16ArrayAsInt16X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt32ArrayAsInt32X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt64ArrayAsInt64X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord8ArrayAsWord8X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord16ArrayAsWord16X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord32ArrayAsWord32X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord64ArrayAsWord64X2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord8ArrayAsWord8X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord16ArrayAsWord16X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord32ArrayAsWord32X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord64ArrayAsWord64X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord8ArrayAsWord8X64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord16ArrayAsWord16X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord32ArrayAsWord32X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord64ArrayAsWord64X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readFloatArrayAsFloatX4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readDoubleArrayAsDoubleX2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readFloatArrayAsFloatX8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readDoubleArrayAsDoubleX4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readFloatArrayAsFloatX16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)

-- | Read a vector from specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readDoubleArrayAsDoubleX8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt8ArrayAsInt8X16# :: MutableByteArray# d -> Int# -> Int8X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt16ArrayAsInt16X8# :: MutableByteArray# d -> Int# -> Int16X8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt32ArrayAsInt32X4# :: MutableByteArray# d -> Int# -> Int32X4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt64ArrayAsInt64X2# :: MutableByteArray# d -> Int# -> Int64X2# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt8ArrayAsInt8X32# :: MutableByteArray# d -> Int# -> Int8X32# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt16ArrayAsInt16X16# :: MutableByteArray# d -> Int# -> Int16X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt32ArrayAsInt32X8# :: MutableByteArray# d -> Int# -> Int32X8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt64ArrayAsInt64X4# :: MutableByteArray# d -> Int# -> Int64X4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt8ArrayAsInt8X64# :: MutableByteArray# d -> Int# -> Int8X64# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt16ArrayAsInt16X32# :: MutableByteArray# d -> Int# -> Int16X32# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt32ArrayAsInt32X16# :: MutableByteArray# d -> Int# -> Int32X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt64ArrayAsInt64X8# :: MutableByteArray# d -> Int# -> Int64X8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord8ArrayAsWord8X16# :: MutableByteArray# d -> Int# -> Word8X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord16ArrayAsWord16X8# :: MutableByteArray# d -> Int# -> Word16X8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord32ArrayAsWord32X4# :: MutableByteArray# d -> Int# -> Word32X4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord64ArrayAsWord64X2# :: MutableByteArray# d -> Int# -> Word64X2# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord8ArrayAsWord8X32# :: MutableByteArray# d -> Int# -> Word8X32# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord16ArrayAsWord16X16# :: MutableByteArray# d -> Int# -> Word16X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord32ArrayAsWord32X8# :: MutableByteArray# d -> Int# -> Word32X8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord64ArrayAsWord64X4# :: MutableByteArray# d -> Int# -> Word64X4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord8ArrayAsWord8X64# :: MutableByteArray# d -> Int# -> Word8X64# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord16ArrayAsWord16X32# :: MutableByteArray# d -> Int# -> Word16X32# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord32ArrayAsWord32X16# :: MutableByteArray# d -> Int# -> Word32X16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord64ArrayAsWord64X8# :: MutableByteArray# d -> Int# -> Word64X8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeFloatArrayAsFloatX4# :: MutableByteArray# d -> Int# -> FloatX4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeDoubleArrayAsDoubleX2# :: MutableByteArray# d -> Int# -> DoubleX2# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeFloatArrayAsFloatX8# :: MutableByteArray# d -> Int# -> FloatX8# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeDoubleArrayAsDoubleX4# :: MutableByteArray# d -> Int# -> DoubleX4# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeFloatArrayAsFloatX16# :: MutableByteArray# d -> Int# -> FloatX16# -> State# d -> State# d

-- | Write a vector to specified index of mutable array of scalars; offset
--   is in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeDoubleArrayAsDoubleX8# :: MutableByteArray# d -> Int# -> DoubleX8# -> State# d -> State# d

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8#

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt8OffAddrAsInt8X16# :: Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt16OffAddrAsInt16X8# :: Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt8OffAddrAsInt8X32# :: Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt16OffAddrAsInt16X16# :: Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt32OffAddrAsInt32X8# :: Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt64OffAddrAsInt64X4# :: Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt8OffAddrAsInt8X64# :: Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt16OffAddrAsInt16X32# :: Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt32OffAddrAsInt32X16# :: Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readInt64OffAddrAsInt64X8# :: Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord8OffAddrAsWord8X16# :: Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord16OffAddrAsWord16X8# :: Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord32OffAddrAsWord32X4# :: Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord64OffAddrAsWord64X2# :: Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord8OffAddrAsWord8X32# :: Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord16OffAddrAsWord16X16# :: Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord32OffAddrAsWord32X8# :: Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord64OffAddrAsWord64X4# :: Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord8OffAddrAsWord8X64# :: Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord16OffAddrAsWord16X32# :: Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord32OffAddrAsWord32X16# :: Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readWord64OffAddrAsWord64X8# :: Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readFloatOffAddrAsFloatX8# :: Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readFloatOffAddrAsFloatX16# :: Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)

-- | Reads vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
readDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -> State# d -> State# d

-- | Write vector; offset in scalar elements.
--   
--   <b><i>Warning:</i></b> this is only available on LLVM and can fail
--   with an unchecked exception.
writeDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -> State# d -> State# d
prefetchByteArray3# :: ByteArray# -> Int# -> State# d -> State# d
prefetchMutableByteArray3# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchAddr3# :: Addr# -> Int# -> State# d -> State# d
prefetchValue3# :: a -> State# d -> State# d
prefetchByteArray2# :: ByteArray# -> Int# -> State# d -> State# d
prefetchMutableByteArray2# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchAddr2# :: Addr# -> Int# -> State# d -> State# d
prefetchValue2# :: a -> State# d -> State# d
prefetchByteArray1# :: ByteArray# -> Int# -> State# d -> State# d
prefetchMutableByteArray1# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchAddr1# :: Addr# -> Int# -> State# d -> State# d
prefetchValue1# :: a -> State# d -> State# d
prefetchByteArray0# :: ByteArray# -> Int# -> State# d -> State# d
prefetchMutableByteArray0# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchAddr0# :: Addr# -> Int# -> State# d -> State# d
prefetchValue0# :: a -> State# d -> State# d
type WORD64 = Word#
type INT64 = Int#

-- | Retrieves the allocation counter for the current thread.
getThreadAllocationCounter# :: State# RealWorld -> (# State# RealWorld, INT64 #)

-- | Resize a mutable array to new specified size. The returned
--   <a>SmallMutableArray#</a> is either the original
--   <a>SmallMutableArray#</a> resized in-place or, if not possible, a
--   newly allocated <a>SmallMutableArray#</a> with the original content
--   copied over.
--   
--   To avoid undefined behaviour, the original <a>SmallMutableArray#</a>
--   shall not be accessed anymore after a <a>resizeSmallMutableArray#</a>
--   has been performed. Moreover, no reference to the old one should be
--   kept in order to allow garbage collection of the original
--   <a>SmallMutableArray#</a> in case a new <a>SmallMutableArray#</a> had
--   to be allocated.
resizeSmallMutableArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> (# State# s, SmallMutableArray# s a #)

-- | An implementation of the old <tt>atomicModifyMutVar#</tt> primop in
--   terms of the new <a>atomicModifyMutVar2#</a> primop, for backwards
--   compatibility. The type of this function is a bit bogus. It's best to
--   think of it as having type
--   
--   <pre>
--   atomicModifyMutVar#
--     :: MutVar# s a
--     -&gt; (a -&gt; (a, b))
--     -&gt; State# s
--     -&gt; ( s, b #)
--   </pre>
--   
--   but there may be code that uses this with other two-field record
--   types.
atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s, c #)
traceEvent :: String -> IO ()

-- | The <a>sortWith</a> function sorts a list of elements using the user
--   supplied function to project something out of each element
sortWith :: Ord b => (a -> b) -> [a] -> [a]

-- | <a>the</a> ensures that all the elements of the list are identical and
--   then returns that unique element
the :: Eq a => [a] -> a
maxTupleSize :: Int
data SpecConstrAnnotation
NoSpecConstr :: SpecConstrAnnotation
ForceSpecConstr :: SpecConstrAnnotation

-- | The <a>Item</a> type function returns the type of items of the
--   structure <tt>l</tt>.
type family Item l

-- | The <a>Down</a> type allows you to reverse sort order conveniently. A
--   value of type <tt><a>Down</a> a</tt> contains a value of type
--   <tt>a</tt> (represented as <tt><a>Down</a> a</tt>). If <tt>a</tt> has
--   an <tt><a>Ord</a></tt> instance associated with it then comparing two
--   values thus wrapped will give you the opposite of their normal sort
--   order. This is particularly useful when sorting in generalised list
--   comprehensions, as in: <tt>then sortWith by <a>Down</a> x</tt>
newtype Down a
Down :: a -> Down a

[getDown] :: Down a -> a
uncheckedIShiftRA64# :: Int# -> Int# -> Int#
uncheckedIShiftL64# :: Int# -> Int# -> Int#
uncheckedShiftRL64# :: Word# -> Int# -> Word#
uncheckedShiftL64# :: Word# -> Int# -> Word#

-- | Returns a <tt>[String]</tt> representing the current call stack. This
--   can be useful for debugging.
--   
--   The implementation uses the call-stack simulation maintained by the
--   profiler, so it only works if the program was compiled with
--   <tt>-prof</tt> and contains suitable SCC annotations (e.g. by using
--   <tt>-fprof-auto</tt>). Otherwise, the list returned is likely to be
--   empty or uninformative.
currentCallStack :: IO [String]

-- | Shift the argument right (unsigned) by the specified number of bits
--   (which must be non-negative). The <a>RL</a> means "right, logical" (as
--   opposed to RA for arithmetic)
iShiftRL# :: Int# -> Int# -> Int#

-- | Shift the argument right (signed) by the specified number of bits
--   (which must be non-negative). The <a>RA</a> means "right, arithmetic"
--   (as opposed to RL for logical)
iShiftRA# :: Int# -> Int# -> Int#

-- | Shift the argument left by the specified number of bits (which must be
--   non-negative).
iShiftL# :: Int# -> Int# -> Int#

-- | Shift the argument right by the specified number of bits (which must
--   be non-negative). The <a>RL</a> means "right, logical" (as opposed to
--   RA for arithmetic) (although an arithmetic right shift wouldn't make
--   sense for Word#)
shiftRL# :: Word# -> Int# -> Word#

-- | Shift the argument left by the specified number of bits (which must be
--   non-negative).
shiftL# :: Word# -> Int# -> Word#

-- | Alias for <a>tagToEnum#</a>. Returns True if its parameter is 1# and
--   False if it is 0#.
isTrue# :: Int# -> Bool


module Data.Prim.Class

-- | Invariants:
--   
--   <ul>
--   <li>Reading should never fail on memory that contains only zeros</li>
--   <li>Writing should always overwrite all of the bytes allocated for the
--   element. In other words, writing to a dirty (uninitilized) region of
--   memory should never leave any garbage around. For example, if a type
--   requires 31 bytes of memory then on any write all 31 bytes must be
--   overwritten.</li>
--   <li>A single thread write/read sequence must always roundtrip</li>
--   <li>This is not a class for serialization, therefore memory layout of
--   unpacked datatype is selfcontained in <a>Prim</a> class and
--   representation is not expected to stay the same between different
--   versions of software. Primitive types like <a>Int</a>, <a>Word</a>,
--   <a>Char</a> are an exception to this rule for obvious reasons.</li>
--   </ul>
class Prim a where {
    type family PrimBase a :: *;
    type family SizeOf a :: Nat;
    type family Alignment a :: Nat;
    type SizeOf a = SizeOf (PrimBase a);
    type Alignment a = Alignment (PrimBase a);
}
toPrimBase :: Prim a => a -> PrimBase a
toPrimBase :: (Prim a, Coercible a (PrimBase a)) => a -> PrimBase a
fromPrimBase :: Prim a => PrimBase a -> a
fromPrimBase :: (Prim a, Coercible a (PrimBase a)) => PrimBase a -> a

-- | Returned value must match the <a>SizeOf</a> type level Nat
sizeOf# :: Prim a => Proxy# a -> Int#

-- | Returned value must match the <a>SizeOf</a> type level Nat
sizeOf# :: (Prim a, Prim (PrimBase a)) => Proxy# a -> Int#

-- | Returned value must match the <a>Alignment</a> type level Nat
alignment# :: Prim a => Proxy# a -> Int#

-- | Returned value must match the <a>Alignment</a> type level Nat
alignment# :: (Prim a, Prim (PrimBase a)) => Proxy# a -> Int#
indexByteOffByteArray# :: Prim a => ByteArray# -> Int# -> a
indexByteOffByteArray# :: (Prim a, Prim (PrimBase a)) => ByteArray# -> Int# -> a
indexByteArray# :: Prim a => ByteArray# -> Int# -> a
indexByteArray# :: (Prim a, Prim (PrimBase a)) => ByteArray# -> Int# -> a
indexOffAddr# :: Prim a => Addr# -> Int# -> a
indexOffAddr# :: (Prim a, Prim (PrimBase a)) => Addr# -> Int# -> a
readByteOffMutableByteArray# :: Prim a => MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
readByteOffMutableByteArray# :: (Prim a, Prim (PrimBase a)) => MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
readMutableByteArray# :: Prim a => MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
readMutableByteArray# :: (Prim a, Prim (PrimBase a)) => MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
readOffAddr# :: Prim a => Addr# -> Int# -> State# s -> (# State# s, a #)
readOffAddr# :: (Prim a, Prim (PrimBase a)) => Addr# -> Int# -> State# s -> (# State# s, a #)
writeByteOffMutableByteArray# :: Prim a => MutableByteArray# s -> Int# -> a -> State# s -> State# s
writeByteOffMutableByteArray# :: (Prim a, Prim (PrimBase a)) => MutableByteArray# s -> Int# -> a -> State# s -> State# s
writeMutableByteArray# :: Prim a => MutableByteArray# s -> Int# -> a -> State# s -> State# s
writeMutableByteArray# :: (Prim a, Prim (PrimBase a)) => MutableByteArray# s -> Int# -> a -> State# s -> State# s
writeOffAddr# :: Prim a => Addr# -> Int# -> a -> State# s -> State# s
writeOffAddr# :: (Prim a, Prim (PrimBase a)) => Addr# -> Int# -> a -> State# s -> State# s

-- | Set the region of MutableByteArray to the same value. Offset is in
--   number of elements
setMutableByteArray# :: Prim a => MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s

-- | Set the region of MutableByteArray to the same value. Offset is in
--   number of elements
setMutableByteArray# :: (Prim a, Prim (PrimBase a)) => MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s

-- | Set the region of memory to the same value. Offset is in number of
--   elements
setOffAddr# :: Prim a => Addr# -> Int# -> Int# -> a -> State# s -> State# s

-- | Set the region of memory to the same value. Offset is in number of
--   elements
setOffAddr# :: (Prim a, Prim (PrimBase a)) => Addr# -> Int# -> Int# -> a -> State# s -> State# s

-- | A loop that uses <a>writeMutableByteArray#</a> to set the values in
--   the region. It is a suboptimal way to fill the memory with a single
--   value that is why it is only provided here for convenience
setMutableByteArrayLoop# :: Prim a => MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s
setOffAddrLoop# :: Prim a => Addr# -> Int# -> Int# -> a -> State# s -> State# s
errorImpossible :: String -> String -> a
bool2Int# :: Bool -> Int#
int2Bool# :: Int# -> Bool

-- | An unsigned integral type that can be losslessly converted to and from
--   <tt>Ptr</tt>. This type is also compatible with the C99 type
--   <tt>uintptr_t</tt>, and can be marshalled to and from that type
--   safely.
newtype WordPtr
WordPtr :: Word -> WordPtr

-- | casts a <tt>Ptr</tt> to a <tt>WordPtr</tt>
ptrToWordPtr :: Ptr a -> WordPtr

-- | casts a <tt>WordPtr</tt> to a <tt>Ptr</tt>
wordPtrToPtr :: WordPtr -> Ptr a

-- | A signed integral type that can be losslessly converted to and from
--   <tt>Ptr</tt>. This type is also compatible with the C99 type
--   <tt>intptr_t</tt>, and can be marshalled to and from that type safely.
newtype IntPtr
IntPtr :: Int -> IntPtr

-- | casts a <tt>Ptr</tt> to an <tt>IntPtr</tt>
ptrToIntPtr :: Ptr a -> IntPtr

-- | casts an <tt>IntPtr</tt> to a <tt>Ptr</tt>
intPtrToPtr :: IntPtr -> Ptr a
instance (Data.Prim.Class.Prim a, Data.Prim.Class.Prim b) => Data.Prim.Class.Prim (Data.Either.Either a b)
instance Data.Prim.Class.Prim ()
instance forall k (a :: k) (b :: k). (a GHC.Types.~ b) => Data.Prim.Class.Prim (a Data.Type.Equality.:~: b)
instance Data.Prim.Class.Prim GHC.Types.Int
instance Data.Prim.Class.Prim GHC.Int.Int8
instance Data.Prim.Class.Prim GHC.Int.Int16
instance Data.Prim.Class.Prim GHC.Int.Int32
instance Data.Prim.Class.Prim GHC.Int.Int64
instance Data.Prim.Class.Prim GHC.Types.Word
instance Data.Prim.Class.Prim GHC.Word.Word8
instance Data.Prim.Class.Prim GHC.Word.Word16
instance Data.Prim.Class.Prim GHC.Word.Word32
instance Data.Prim.Class.Prim GHC.Word.Word64
instance Data.Prim.Class.Prim GHC.Types.Float
instance Data.Prim.Class.Prim GHC.Types.Double
instance Data.Prim.Class.Prim GHC.Types.Bool
instance Data.Prim.Class.Prim GHC.Types.Char
instance Data.Prim.Class.Prim (GHC.Ptr.Ptr a)
instance Data.Prim.Class.Prim (GHC.Ptr.FunPtr a)
instance Data.Prim.Class.Prim (GHC.Stable.StablePtr a)
instance Data.Prim.Class.Prim Foreign.Ptr.IntPtr
instance Data.Prim.Class.Prim Foreign.Ptr.WordPtr
instance Data.Prim.Class.Prim Foreign.C.Types.CBool
instance Data.Prim.Class.Prim Foreign.C.Types.CChar
instance Data.Prim.Class.Prim Foreign.C.Types.CSChar
instance Data.Prim.Class.Prim Foreign.C.Types.CUChar
instance Data.Prim.Class.Prim Foreign.C.Types.CShort
instance Data.Prim.Class.Prim Foreign.C.Types.CUShort
instance Data.Prim.Class.Prim Foreign.C.Types.CInt
instance Data.Prim.Class.Prim Foreign.C.Types.CUInt
instance Data.Prim.Class.Prim Foreign.C.Types.CLong
instance Data.Prim.Class.Prim Foreign.C.Types.CULong
instance Data.Prim.Class.Prim Foreign.C.Types.CLLong
instance Data.Prim.Class.Prim Foreign.C.Types.CULLong
instance Data.Prim.Class.Prim Foreign.C.Types.CPtrdiff
instance Data.Prim.Class.Prim Foreign.C.Types.CSize
instance Data.Prim.Class.Prim Foreign.C.Types.CWchar
instance Data.Prim.Class.Prim Foreign.C.Types.CSigAtomic
instance Data.Prim.Class.Prim Foreign.C.Types.CIntPtr
instance Data.Prim.Class.Prim Foreign.C.Types.CUIntPtr
instance Data.Prim.Class.Prim Foreign.C.Types.CIntMax
instance Data.Prim.Class.Prim Foreign.C.Types.CUIntMax
instance Data.Prim.Class.Prim Foreign.C.Types.CFloat
instance Data.Prim.Class.Prim Foreign.C.Types.CDouble
instance Data.Prim.Class.Prim System.Posix.Types.Fd
instance Data.Prim.Class.Prim Foreign.C.Error.Errno
instance Data.Prim.Class.Prim System.Posix.Types.CDev
instance Data.Prim.Class.Prim System.Posix.Types.CIno
instance Data.Prim.Class.Prim System.Posix.Types.CMode
instance Data.Prim.Class.Prim System.Posix.Types.COff
instance Data.Prim.Class.Prim System.Posix.Types.CPid
instance Data.Prim.Class.Prim System.Posix.Types.CSsize
instance Data.Prim.Class.Prim System.Posix.Types.CGid
instance Data.Prim.Class.Prim System.Posix.Types.CNlink
instance Data.Prim.Class.Prim System.Posix.Types.CUid
instance Data.Prim.Class.Prim System.Posix.Types.CCc
instance Data.Prim.Class.Prim System.Posix.Types.CSpeed
instance Data.Prim.Class.Prim System.Posix.Types.CTcflag
instance Data.Prim.Class.Prim System.Posix.Types.CRLim
instance Data.Prim.Class.Prim a => Data.Prim.Class.Prim (Data.Semigroup.Max a)
instance Data.Prim.Class.Prim a => Data.Prim.Class.Prim (Data.Semigroup.Min a)
instance Data.Prim.Class.Prim a => Data.Prim.Class.Prim (Data.Semigroup.First a)
instance Data.Prim.Class.Prim a => Data.Prim.Class.Prim (Data.Semigroup.Last a)
instance (Data.Prim.Class.Prim a, Data.Prim.Class.Prim b) => Data.Prim.Class.Prim (Data.Semigroup.Arg a b)
instance forall k a (b :: k). Data.Prim.Class.Prim a => Data.Prim.Class.Prim (Data.Functor.Const.Const a b)
instance forall k2 (a :: k2) (b :: k2). (a GHC.Types.~ b) => Data.Prim.Class.Prim (a Data.Type.Equality.:~~: b)
instance Data.Prim.Class.Prim System.Posix.Types.CBlkSize
instance Data.Prim.Class.Prim System.Posix.Types.CBlkCnt
instance Data.Prim.Class.Prim System.Posix.Types.CClockId
instance Data.Prim.Class.Prim System.Posix.Types.CFsBlkCnt
instance Data.Prim.Class.Prim System.Posix.Types.CFsFilCnt
instance Data.Prim.Class.Prim System.Posix.Types.CId
instance Data.Prim.Class.Prim System.Posix.Types.CKey
instance Data.Prim.Class.Prim System.Posix.Types.CTimer
instance Data.Prim.Class.Prim System.Posix.Types.CSocklen
instance Data.Prim.Class.Prim System.Posix.Types.CNfds
instance forall k (f :: k -> *) (a :: k). Data.Prim.Class.Prim (f a) => Data.Prim.Class.Prim (Data.Monoid.Ap f a)
instance forall k (f :: k -> *) (a :: k) (g :: k -> *). (Data.Prim.Class.Prim (f a), Data.Prim.Class.Prim (g a)) => Data.Prim.Class.Prim (Data.Functor.Product.Product f g a)
instance forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1). Data.Prim.Class.Prim (f (g a)) => Data.Prim.Class.Prim (Data.Functor.Compose.Compose f g a)
instance Data.Prim.Class.Prim a => Data.Prim.Class.Prim (Data.Functor.Identity.Identity a)
instance forall k (f :: k -> *) (a :: k). Data.Prim.Class.Prim (f a) => Data.Prim.Class.Prim (Data.Semigroup.Internal.Alt f a)
instance Data.Prim.Class.Prim GHC.Types.Ordering
instance Data.Prim.Class.Prim GHC.IO.Device.IODeviceType
instance Data.Prim.Class.Prim GHC.IO.Device.SeekMode
instance Data.Prim.Class.Prim GHC.Conc.Sync.BlockReason
instance Data.Prim.Class.Prim GHC.Conc.Sync.ThreadStatus
instance Data.Prim.Class.Prim GHC.IO.IOMode.IOMode
instance Data.Prim.Class.Prim GHC.IO.Handle.Types.BufferMode
instance Data.Prim.Class.Prim GHC.IO.Handle.Types.Newline
instance Data.Prim.Class.Prim GHC.IO.Handle.Types.NewlineMode
instance Data.Prim.Class.Prim GHC.Unicode.GeneralCategory
instance Data.Prim.Class.Prim a => Data.Prim.Class.Prim (Data.Ord.Down a)
instance Data.Prim.Class.Prim a => Data.Prim.Class.Prim (Data.Semigroup.Internal.Dual a)
instance Data.Prim.Class.Prim a => Data.Prim.Class.Prim (Data.Semigroup.Internal.Sum a)
instance Data.Prim.Class.Prim a => Data.Prim.Class.Prim (Data.Semigroup.Internal.Product a)
instance Data.Prim.Class.Prim Data.Semigroup.Internal.All
instance Data.Prim.Class.Prim Data.Semigroup.Internal.Any
instance Data.Prim.Class.Prim GHC.Fingerprint.Type.Fingerprint
instance Data.Prim.Class.Prim a => Data.Prim.Class.Prim (GHC.Real.Ratio a)
instance Data.Prim.Class.Prim a => Data.Prim.Class.Prim (Data.Complex.Complex a)
instance (Data.Prim.Class.Prim a, Data.Prim.Class.Prim b) => Data.Prim.Class.Prim (a, b)
instance (Data.Prim.Class.Prim a, Data.Prim.Class.Prim b, Data.Prim.Class.Prim c) => Data.Prim.Class.Prim (a, b, c)
instance (Data.Prim.Class.Prim a, Data.Prim.Class.Prim b, Data.Prim.Class.Prim c, Data.Prim.Class.Prim d) => Data.Prim.Class.Prim (a, b, c, d)
instance (Data.Prim.Class.Prim a, Data.Prim.Class.Prim b, Data.Prim.Class.Prim c, Data.Prim.Class.Prim d, Data.Prim.Class.Prim e) => Data.Prim.Class.Prim (a, b, c, d, e)
instance (Data.Prim.Class.Prim a, Data.Prim.Class.Prim b, Data.Prim.Class.Prim c, Data.Prim.Class.Prim d, Data.Prim.Class.Prim e, Data.Prim.Class.Prim f) => Data.Prim.Class.Prim (a, b, c, d, e, f)
instance (Data.Prim.Class.Prim a, Data.Prim.Class.Prim b, Data.Prim.Class.Prim c, Data.Prim.Class.Prim d, Data.Prim.Class.Prim e, Data.Prim.Class.Prim f, Data.Prim.Class.Prim g) => Data.Prim.Class.Prim (a, b, c, d, e, f, g)
instance (Data.Prim.Class.Prim a, Data.Prim.Class.Prim b, Data.Prim.Class.Prim c, Data.Prim.Class.Prim d, Data.Prim.Class.Prim e, Data.Prim.Class.Prim f, Data.Prim.Class.Prim g, Data.Prim.Class.Prim h) => Data.Prim.Class.Prim (a, b, c, d, e, f, g, h)
instance (Data.Prim.Class.Prim a, Data.Prim.Class.Prim b, Data.Prim.Class.Prim c, Data.Prim.Class.Prim d, Data.Prim.Class.Prim e, Data.Prim.Class.Prim f, Data.Prim.Class.Prim g, Data.Prim.Class.Prim h, Data.Prim.Class.Prim i) => Data.Prim.Class.Prim (a, b, c, d, e, f, g, h, i)
instance Data.Prim.Class.Prim a => Data.Prim.Class.Prim (GHC.Maybe.Maybe a)


module Data.Prim.Atomic
class (Prim a, Eq a) => Atomic a

-- | Read an element from <a>MutableByteArray#</a> atomically. Implies full
--   memory barrier.
atomicReadMutableByteArray# :: Atomic a => MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)

-- | Write an element into <a>MutableByteArray#</a> atomically. Implies
--   full memory barrier.
atomicWriteMutableByteArray# :: Atomic a => MutableByteArray# s -> Int# -> a -> State# s -> State# s

-- | Read an element from memory atomically. Implies full memory barrier.
atomicReadOffAddr# :: Atomic a => Addr# -> Int# -> State# s -> (# State# s, a #)

-- | Write an element directly into memory atomically. Implies full memory
--   barrier.
atomicWriteOffAddr# :: Atomic a => Addr# -> Int# -> a -> State# s -> State# s

-- | Compare-and-swap (CAS) operation. Given a mutable array, offset in
--   number of elements, an old value and a new value atomically swap the
--   old value for the new one, but only if the actual old value was an
--   exact match to the expetced old one that was supplied. Returns the
--   actual old value, which if compared to supplied expected one will tell
--   us whether atomic swap occured or not.
casMutableByteArray# :: Atomic a => MutableByteArray# s -> Int# -> a -> a -> State# s -> (# State# s, a #)

-- | Compare-and-swap (CAS) operation. Given a mutable array, offset in
--   number of elements, an old value and a new value atomically swap the
--   old value for the new one, but only if the actual old value was an
--   exact match to the expetced old one that was supplied. Returns the
--   actual old value, which if compared to supplied expected one will tell
--   us whether atomic swap occured or not.
casMutableByteArray# :: (Atomic a, Atomic (PrimBase a)) => MutableByteArray# s -> Int# -> a -> a -> State# s -> (# State# s, a #)
casOffAddr# :: Atomic a => Addr# -> Int# -> a -> a -> State# s -> (# State# s, a #)
casOffAddr# :: (Atomic a, Atomic (PrimBase a)) => Addr# -> Int# -> a -> a -> State# s -> (# State# s, a #)
casBoolMutableByteArray# :: Atomic a => MutableByteArray# s -> Int# -> a -> a -> State# s -> (# State# s, Bool #)
casBoolMutableByteArray# :: (Atomic a, Atomic (PrimBase a)) => MutableByteArray# s -> Int# -> a -> a -> State# s -> (# State# s, Bool #)
casBoolOffAddr# :: Atomic a => Addr# -> Int# -> a -> a -> State# s -> (# State# s, Bool #)
casBoolOffAddr# :: (Atomic a, Atomic (PrimBase a)) => Addr# -> Int# -> a -> a -> State# s -> (# State# s, Bool #)

-- | Using <a>casMutableByteArray#</a> perform atomic modification of an
--   element in a <a>MutableByteArray#</a>. This is essentially an
--   implementation of a spinlock using CAS.
atomicModifyMutableByteArray# :: Atomic a => MutableByteArray# s -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)

-- | Using <a>casOffAddr#</a> perform atomic modification of an element in
--   a <tt>OffAddr#</tt>. This is essentially an implementation of a
--   spinlock using CAS.
atomicModifyOffAddr# :: Atomic a => Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
class (Bits a, Atomic a) => AtomicBits a
atomicAndFetchOldMutableByteArray# :: AtomicBits a => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchOldMutableByteArray# :: (AtomicBits a, AtomicBits (PrimBase a)) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchNewMutableByteArray# :: AtomicBits a => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchNewMutableByteArray# :: (AtomicBits a, AtomicBits (PrimBase a)) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchOldMutableByteArray# :: AtomicBits a => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchOldMutableByteArray# :: (AtomicBits a, AtomicBits (PrimBase a)) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchNewMutableByteArray# :: AtomicBits a => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchNewMutableByteArray# :: (AtomicBits a, AtomicBits (PrimBase a)) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchOldMutableByteArray# :: AtomicBits a => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchOldMutableByteArray# :: (AtomicBits a, AtomicBits (PrimBase a)) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchNewMutableByteArray# :: AtomicBits a => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchNewMutableByteArray# :: (AtomicBits a, AtomicBits (PrimBase a)) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchOldMutableByteArray# :: AtomicBits a => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchOldMutableByteArray# :: (AtomicBits a, AtomicBits (PrimBase a)) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchNewMutableByteArray# :: AtomicBits a => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchNewMutableByteArray# :: (AtomicBits a, AtomicBits (PrimBase a)) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchOldOffAddr# :: AtomicBits a => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchOldOffAddr# :: (AtomicBits a, AtomicBits (PrimBase a)) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchNewOffAddr# :: AtomicBits a => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchNewOffAddr# :: (AtomicBits a, AtomicBits (PrimBase a)) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchOldOffAddr# :: AtomicBits a => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchOldOffAddr# :: (AtomicBits a, AtomicBits (PrimBase a)) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchNewOffAddr# :: AtomicBits a => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchNewOffAddr# :: (AtomicBits a, AtomicBits (PrimBase a)) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchOldOffAddr# :: AtomicBits a => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchOldOffAddr# :: (AtomicBits a, AtomicBits (PrimBase a)) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchNewOffAddr# :: AtomicBits a => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchNewOffAddr# :: (AtomicBits a, AtomicBits (PrimBase a)) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchOldOffAddr# :: AtomicBits a => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchOldOffAddr# :: (AtomicBits a, AtomicBits (PrimBase a)) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchNewOffAddr# :: AtomicBits a => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchNewOffAddr# :: (AtomicBits a, AtomicBits (PrimBase a)) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
class Atomic a => AtomicCount a
atomicAddFetchOldMutableByteArray# :: AtomicCount a => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchOldMutableByteArray# :: (AtomicCount a, AtomicCount (PrimBase a)) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchNewMutableByteArray# :: AtomicCount a => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchNewMutableByteArray# :: (AtomicCount a, AtomicCount (PrimBase a)) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchOldMutableByteArray# :: AtomicCount a => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchOldMutableByteArray# :: (AtomicCount a, AtomicCount (PrimBase a)) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchNewMutableByteArray# :: AtomicCount a => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchNewMutableByteArray# :: (AtomicCount a, AtomicCount (PrimBase a)) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchOldOffAddr# :: AtomicCount a => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchOldOffAddr# :: (AtomicCount a, AtomicCount (PrimBase a)) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchNewOffAddr# :: AtomicCount a => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchNewOffAddr# :: (AtomicCount a, AtomicCount (PrimBase a)) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchOldOffAddr# :: AtomicCount a => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchOldOffAddr# :: (AtomicCount a, AtomicCount (PrimBase a)) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchNewOffAddr# :: AtomicCount a => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchNewOffAddr# :: (AtomicCount a, AtomicCount (PrimBase a)) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)

-- | Using <a>casBoolMutableByteArray#</a> perform atomic modification of
--   an element in a <a>MutableByteArray#</a>. This is essentially an
--   implementation of a spinlock using CAS.
atomicBoolModifyMutableByteArray# :: Atomic a => MutableByteArray# s -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)

-- | Using <a>casBoolMutableByteArray#</a> perform atomic modification of
--   an element in a <a>MutableByteArray#</a>. Returns the previous value.
atomicBoolModifyFetchOldMutableByteArray# :: Atomic a => MutableByteArray# s -> Int# -> (a -> a) -> State# s -> (# State# s, a #)

-- | Using <a>casMutableByteArray#</a> perform atomic modification of an
--   element in a <a>MutableByteArray#</a>.
atomicModifyMutableByteArray_# :: Atomic a => MutableByteArray# s -> Int# -> (a -> a) -> State# s -> State# s

-- | Using <a>casMutableByteArray#</a> perform atomic modification of an
--   element in a <a>MutableByteArray#</a>. Returns the previous value.
atomicModifyFetchOldMutableByteArray# :: Atomic a => MutableByteArray# s -> Int# -> (a -> a) -> State# s -> (# State# s, a #)

-- | Using <a>casMutableByteArray#</a> perform atomic modification of an
--   element in a <a>MutableByteArray#</a>. Returns the new value.
atomicModifyFetchNewMutableByteArray# :: Atomic a => MutableByteArray# s -> Int# -> (a -> a) -> State# s -> (# State# s, a #)

-- | Using <a>casOffAddr#</a> perform atomic modification of an element in
--   a <tt>OffAddr#</tt>.
atomicModifyOffAddr_# :: Atomic a => Addr# -> Int# -> (a -> a) -> State# s -> State# s

-- | Using <a>casBoolOffAddr#</a> perform atomic modification of an element
--   in a <tt>OffAddr#</tt>. This is essentially an implementation of a
--   spinlock using CAS.
atomicBoolModifyOffAddr# :: Atomic a => Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)

-- | Using <a>casOffAddr#</a> perform atomic modification of an element in
--   a <tt>OffAddr#</tt>. Returns the previous value.
atomicModifyFetchOldOffAddr# :: Atomic a => Addr# -> Int# -> (a -> a) -> State# s -> (# State# s, a #)

-- | Using <a>casOffAddr#</a> perform atomic modification of an element in
--   a <tt>OffAddr#</tt>. Returns the new value.
atomicModifyFetchNewOffAddr# :: Atomic a => Addr# -> Int# -> (a -> a) -> State# s -> (# State# s, a #)

-- | Flip all bits atomically in the element of an array at the supplied
--   offset. Returns the previous value. Implies full memory barrier.
atomicNotFetchOldMutableByteArray# :: forall a s. AtomicBits a => MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)

-- | Flip all bits atomically in the element of an array at the supplied
--   offset. Returns the new value. Implies full memory barrier.
atomicNotFetchNewMutableByteArray# :: forall a s. AtomicBits a => MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)

-- | Flip all bits atomically in the element of an array at the supplied
--   offset. Returns the previous value. Implies full memory barrier.
atomicNotFetchOldOffAddr# :: forall a s. AtomicBits a => Addr# -> Int# -> State# s -> (# State# s, a #)

-- | Flip all bits atomically in the element of an array at the supplied
--   offset. Returns the new value. Implies full memory barrier.
atomicNotFetchNewOffAddr# :: forall a s. AtomicBits a => Addr# -> Int# -> State# s -> (# State# s, a #)
instance Data.Prim.Atomic.AtomicBits GHC.Int.Int8
instance Data.Prim.Atomic.AtomicBits GHC.Int.Int16
instance Data.Prim.Atomic.AtomicBits GHC.Int.Int32
instance Data.Prim.Atomic.AtomicBits GHC.Types.Int
instance Data.Prim.Atomic.AtomicBits GHC.Word.Word8
instance Data.Prim.Atomic.AtomicBits GHC.Word.Word16
instance Data.Prim.Atomic.AtomicBits GHC.Word.Word32
instance Data.Prim.Atomic.AtomicBits GHC.Types.Word
instance Data.Prim.Atomic.AtomicBits GHC.Int.Int64
instance Data.Prim.Atomic.AtomicBits GHC.Word.Word64
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CLLong
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CULLong
instance Data.Prim.Atomic.AtomicBits GHC.Types.Bool
instance Data.Prim.Atomic.AtomicBits Foreign.Ptr.IntPtr
instance Data.Prim.Atomic.AtomicBits Foreign.Ptr.WordPtr
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CBool
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CChar
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CSChar
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CUChar
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CShort
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CUShort
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CInt
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CUInt
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CLong
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CULong
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CPtrdiff
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CSize
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CWchar
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CSigAtomic
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CIntPtr
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CUIntPtr
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CIntMax
instance Data.Prim.Atomic.AtomicBits Foreign.C.Types.CUIntMax
instance Data.Prim.Atomic.AtomicBits System.Posix.Types.Fd
instance Data.Prim.Atomic.AtomicBits a => Data.Prim.Atomic.AtomicBits (Data.Functor.Const.Const a b)
instance Data.Prim.Atomic.AtomicBits a => Data.Prim.Atomic.AtomicBits (Data.Functor.Identity.Identity a)
instance Data.Prim.Atomic.AtomicCount GHC.Int.Int8
instance Data.Prim.Atomic.AtomicCount GHC.Int.Int16
instance Data.Prim.Atomic.AtomicCount GHC.Int.Int32
instance Data.Prim.Atomic.AtomicCount GHC.Types.Int
instance Data.Prim.Atomic.AtomicCount GHC.Word.Word8
instance Data.Prim.Atomic.AtomicCount GHC.Word.Word16
instance Data.Prim.Atomic.AtomicCount GHC.Word.Word32
instance Data.Prim.Atomic.AtomicCount GHC.Types.Word
instance Data.Prim.Atomic.AtomicCount GHC.Int.Int64
instance Data.Prim.Atomic.AtomicCount GHC.Word.Word64
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CLLong
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CULLong
instance Data.Prim.Atomic.AtomicCount Foreign.Ptr.IntPtr
instance Data.Prim.Atomic.AtomicCount Foreign.Ptr.WordPtr
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CBool
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CChar
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CSChar
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CUChar
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CShort
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CUShort
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CInt
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CUInt
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CLong
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CULong
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CPtrdiff
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CSize
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CWchar
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CSigAtomic
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CIntPtr
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CUIntPtr
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CIntMax
instance Data.Prim.Atomic.AtomicCount Foreign.C.Types.CUIntMax
instance Data.Prim.Atomic.AtomicCount System.Posix.Types.Fd
instance Data.Prim.Atomic.AtomicCount Foreign.C.Error.Errno
instance Data.Prim.Atomic.AtomicCount a => Data.Prim.Atomic.AtomicCount (Data.Functor.Const.Const a b)
instance Data.Prim.Atomic.AtomicCount a => Data.Prim.Atomic.AtomicCount (Data.Functor.Identity.Identity a)
instance Data.Prim.Atomic.AtomicCount a => Data.Prim.Atomic.AtomicCount (Data.Ord.Down a)
instance Data.Prim.Atomic.AtomicCount a => Data.Prim.Atomic.AtomicCount (Data.Semigroup.Internal.Dual a)
instance Data.Prim.Atomic.AtomicCount a => Data.Prim.Atomic.AtomicCount (Data.Semigroup.Internal.Sum a)
instance Data.Prim.Atomic.AtomicCount a => Data.Prim.Atomic.AtomicCount (Data.Semigroup.Internal.Product a)
instance Data.Prim.Atomic.Atomic GHC.Int.Int8
instance Data.Prim.Atomic.Atomic GHC.Int.Int16
instance Data.Prim.Atomic.Atomic GHC.Int.Int32
instance Data.Prim.Atomic.Atomic GHC.Types.Int
instance Data.Prim.Atomic.Atomic GHC.Word.Word8
instance Data.Prim.Atomic.Atomic GHC.Word.Word16
instance Data.Prim.Atomic.Atomic GHC.Word.Word32
instance Data.Prim.Atomic.Atomic GHC.Types.Word
instance Data.Prim.Atomic.Atomic GHC.Int.Int64
instance Data.Prim.Atomic.Atomic GHC.Word.Word64
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CLLong
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CULLong
instance Data.Prim.Atomic.Atomic GHC.Types.Bool
instance Data.Prim.Atomic.Atomic GHC.Types.Char
instance Data.Prim.Atomic.Atomic (GHC.Ptr.Ptr a)
instance Data.Prim.Atomic.Atomic (GHC.Ptr.FunPtr a)
instance Data.Prim.Atomic.Atomic Foreign.Ptr.IntPtr
instance Data.Prim.Atomic.Atomic Foreign.Ptr.WordPtr
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CBool
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CChar
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CSChar
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CUChar
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CShort
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CUShort
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CInt
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CUInt
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CLong
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CULong
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CPtrdiff
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CSize
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CWchar
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CSigAtomic
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CIntPtr
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CUIntPtr
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CIntMax
instance Data.Prim.Atomic.Atomic Foreign.C.Types.CUIntMax
instance Data.Prim.Atomic.Atomic System.Posix.Types.Fd
instance Data.Prim.Atomic.Atomic Foreign.C.Error.Errno
instance Data.Prim.Atomic.Atomic a => Data.Prim.Atomic.Atomic (Data.Semigroup.Max a)
instance Data.Prim.Atomic.Atomic a => Data.Prim.Atomic.Atomic (Data.Semigroup.Min a)
instance Data.Prim.Atomic.Atomic a => Data.Prim.Atomic.Atomic (Data.Semigroup.First a)
instance Data.Prim.Atomic.Atomic a => Data.Prim.Atomic.Atomic (Data.Semigroup.Last a)
instance Data.Prim.Atomic.Atomic a => Data.Prim.Atomic.Atomic (Data.Functor.Const.Const a b)
instance Data.Prim.Atomic.Atomic a => Data.Prim.Atomic.Atomic (Data.Functor.Identity.Identity a)
instance Data.Prim.Atomic.Atomic GHC.Types.Ordering
instance Data.Prim.Atomic.Atomic GHC.IO.Device.IODeviceType
instance Data.Prim.Atomic.Atomic GHC.IO.Device.SeekMode
instance Data.Prim.Atomic.Atomic GHC.Conc.Sync.BlockReason
instance Data.Prim.Atomic.Atomic GHC.Conc.Sync.ThreadStatus
instance Data.Prim.Atomic.Atomic GHC.IO.IOMode.IOMode
instance Data.Prim.Atomic.Atomic GHC.IO.Handle.Types.Newline
instance Data.Prim.Atomic.Atomic GHC.IO.Handle.Types.NewlineMode
instance Data.Prim.Atomic.Atomic GHC.Unicode.GeneralCategory
instance Data.Prim.Atomic.Atomic a => Data.Prim.Atomic.Atomic (Data.Ord.Down a)
instance Data.Prim.Atomic.Atomic a => Data.Prim.Atomic.Atomic (Data.Semigroup.Internal.Dual a)
instance Data.Prim.Atomic.Atomic a => Data.Prim.Atomic.Atomic (Data.Semigroup.Internal.Sum a)
instance Data.Prim.Atomic.Atomic a => Data.Prim.Atomic.Atomic (Data.Semigroup.Internal.Product a)
instance Data.Prim.Atomic.Atomic Data.Semigroup.Internal.All
instance Data.Prim.Atomic.Atomic Data.Semigroup.Internal.Any


module Control.Prim.Concurrent

-- | A <a>ThreadId</a> is an abstract type representing a handle to a
--   thread. <a>ThreadId</a> is an instance of <a>Eq</a>, <a>Ord</a> and
--   <a>Show</a>, where the <a>Ord</a> instance implements an arbitrary
--   total ordering over <a>ThreadId</a>s. The <a>Show</a> instance lets
--   you convert an arbitrary-valued <a>ThreadId</a> to string form;
--   showing a <a>ThreadId</a> value is occasionally useful when debugging
--   or diagnosing the behaviour of a concurrent program.
--   
--   <i>Note</i>: in GHC, if you have a <a>ThreadId</a>, you essentially
--   have a pointer to the thread itself. This means the thread itself
--   can't be garbage collected until you drop the <a>ThreadId</a>. This
--   misfeature will hopefully be corrected at a later date.
data ThreadId
ThreadId :: ThreadId# -> ThreadId

-- | Wrapper around <a>fork#</a>. Unlike <a>forkIO</a> it does not install
--   any exception handlers on the action, so you need make sure to do it
--   yourself.
fork :: MonadUnliftPrim RW m => m () -> m ThreadId

-- | Spawn a thread and run an action in it. Any exception raised by the
--   new thread will be passed to the supplied exception handler, which
--   itself will be run in a masked state
forkFinally :: MonadUnliftPrim RW m => m a -> (Either SomeException a -> m ()) -> m ThreadId

-- | Wrapper around <a>forkOn#</a>. Unlike <a>forkOn</a> it does not
--   install any exception handlers on the action, so you need make sure to
--   do it yourself.
forkOn :: MonadUnliftPrim RW m => Int -> m () -> m ThreadId
forkOnFinally :: MonadUnliftPrim RW m => Int -> m a -> (Either SomeException a -> m ()) -> m ThreadId
forkOS :: MonadUnliftPrim RW m => m () -> m ThreadId

-- | Wrapper around <a>killThread#</a>, which throws <a>ThreadKilled</a>
--   exception in the target thread. Use <a>throwTo</a> if you want a
--   different exception to be thrown.
killThread :: MonadPrim RW m => ThreadId -> m ()

-- | Just like <a>yield</a> this is a Wrapper around <a>yield#</a> primop ,
--   except that this version works for any state token. It is safe to use
--   within <a>ST</a> because it can't affect the result of computation,
--   just the order of evaluation with respect to other threads, which is
--   not relevant for the state thread monad anyways.
yield :: forall m s. MonadPrim s m => m ()

-- | Lifted version of <a>threadDelay</a>
threadDelay :: MonadPrim RW m => Int -> m ()

-- | Lifted version of <a>timeout</a>
timeout :: MonadUnliftPrim RW m => Int -> m a -> m (Maybe a)

-- | Same as <a>timeout</a>, but ignores the outcome
timeout_ :: MonadUnliftPrim RW m => Int -> m a -> m ()

-- | Wrapper around <a>myThreadId#</a>.
myThreadId :: MonadPrim RW m => m ThreadId

-- | Something that is not exported from <tt>base</tt>: convert a
--   <a>ThreadId</a> to a regular integral type.
threadIdToCInt :: ThreadId -> CInt
threadStatus :: MonadPrim RW m => ThreadId -> m ThreadStatus

-- | Pointer should refer to UTF8 encoded string of bytes
labelThread :: MonadPrim RW m => ThreadId -> Ptr a -> m ()

-- | Check if current thread was spawned with <a>forkOn#</a>
isCurrentThreadBound :: MonadPrim RW m => m Bool
threadCapability :: MonadPrim RW m => ThreadId -> m (Int, Bool)
getNumCapabilities :: MonadPrim RW m => m Int
setNumCapabilities :: MonadPrim RW m => Int -> m ()
spark :: MonadPrim s m => a -> m a
numSparks :: MonadPrim s m => m Int
runSparks :: MonadPrim s m => m ()

-- | Wrapper for <a>delay#</a>. Sleep specified number of microseconds. Not
--   designed for threaded runtime: <b>Errors when compiled with
--   <tt>-threaded</tt></b>
delay :: MonadPrim s m => Int -> m ()

-- | Wrapper for <a>waitRead#</a>. Block and wait for input to become
--   available on the <a>Fd</a>. Not designed for threaded runtime:
--   <b>Errors out when compiled with <tt>-threaded</tt></b>
waitRead :: MonadPrim s m => Fd -> m ()

-- | Wrapper for <a>waitWrite#</a>. Block and wait until output is possible
--   on the <a>Fd</a>. Not designed for threaded runtime: <b>Errors out
--   when compiled with <tt>-threaded</tt></b>
waitWrite :: MonadPrim s m => Fd -> m ()


module Data.Prim.Atom
newtype Atom a
Atom :: a -> Atom a
[unAtom] :: Atom a -> a
acquireLockByteOffMutableByteArray :: MonadPrim s m => MutableByteArray# s -> Int# -> m ()
releaseLockByteOffMutableByteArray :: MonadPrim s m => MutableByteArray# s -> Int# -> m ()
acquireLockByteOffAddr :: MonadPrim s m => Addr# -> Int# -> m ()
releaseLockByteOffAddr :: MonadPrim s m => Addr# -> Int# -> m ()
withLockMutableByteArray :: forall e a m. (Prim e, MonadUnliftPrim RW m) => MutableByteArray# RealWorld -> Int# -> (Atom e -> m (Atom e, a)) -> m a
withLockOffAddr :: forall e b. Prim e => Addr# -> Int# -> (Atom e -> IO (Atom e, b)) -> IO b
atomicAddFetchOldMutableByteArrayNum# :: (Num a, Atomic a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchNewMutableByteArrayNum# :: (Num a, Atomic a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchOldMutableByteArrayNum# :: (Num a, Atomic a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchNewMutableByteArrayNum# :: (Num a, Atomic a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchOldOffAddrNum# :: (Num a, Atomic a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchNewOffAddrNum# :: (Num a, Atomic a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchOldOffAddrNum# :: (Num a, Atomic a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchNewOffAddrNum# :: (Num a, Atomic a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchOldMutableByteArrayBits# :: (Bits a, Atomic a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchNewMutableByteArrayBits# :: (Bits a, Atomic a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchOldMutableByteArrayBits# :: (Bits a, Atomic a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchNewMutableByteArrayBits# :: (Bits a, Atomic a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchOldMutableByteArrayBits# :: (Bits a, Atomic a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchNewMutableByteArrayBits# :: (Bits a, Atomic a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchOldMutableByteArrayBits# :: (Bits a, Atomic a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchNewMutableByteArrayBits# :: (Bits a, Atomic a) => MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchOldOffAddrBits# :: (Bits a, Atomic a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchNewOffAddrBits# :: (Bits a, Atomic a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchOldOffAddrBits# :: (Bits a, Atomic a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchNewOffAddrBits# :: (Bits a, Atomic a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchOldOffAddrBits# :: (Bits a, Atomic a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchNewOffAddrBits# :: (Bits a, Atomic a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchOldOffAddrBits# :: (Bits a, Atomic a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchNewOffAddrBits# :: (Bits a, Atomic a) => Addr# -> Int# -> a -> State# s -> (# State# s, a #)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Data.Prim.Atom.Atom a)
instance Data.Bits.Bits a => Data.Bits.Bits (Data.Prim.Atom.Atom a)
instance GHC.Float.RealFloat a => GHC.Float.RealFloat (Data.Prim.Atom.Atom a)
instance GHC.Float.Floating a => GHC.Float.Floating (Data.Prim.Atom.Atom a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (Data.Prim.Atom.Atom a)
instance GHC.Real.RealFrac a => GHC.Real.RealFrac (Data.Prim.Atom.Atom a)
instance GHC.Real.Real a => GHC.Real.Real (Data.Prim.Atom.Atom a)
instance GHC.Real.Integral a => GHC.Real.Integral (Data.Prim.Atom.Atom a)
instance GHC.Enum.Enum a => GHC.Enum.Enum (Data.Prim.Atom.Atom a)
instance GHC.Num.Num a => GHC.Num.Num (Data.Prim.Atom.Atom a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Prim.Atom.Atom a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Prim.Atom.Atom a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Prim.Atom.Atom a)
instance Data.Prim.Class.Prim a => Data.Prim.Class.Prim (Data.Prim.Atom.Atom a)
instance (GHC.Classes.Eq a, Data.Prim.Class.Prim a) => Data.Prim.Atomic.Atomic (Data.Prim.Atom.Atom a)
instance (GHC.Num.Num a, GHC.Classes.Eq a, Data.Prim.Class.Prim a) => Data.Prim.Atomic.AtomicCount (Data.Prim.Atom.Atom a)
instance (Data.Bits.Bits a, GHC.Classes.Eq a, Data.Prim.Class.Prim a) => Data.Prim.Atomic.AtomicBits (Data.Prim.Atom.Atom a)


module Data.Prim

-- | Invariants:
--   
--   <ul>
--   <li>Reading should never fail on memory that contains only zeros</li>
--   <li>Writing should always overwrite all of the bytes allocated for the
--   element. In other words, writing to a dirty (uninitilized) region of
--   memory should never leave any garbage around. For example, if a type
--   requires 31 bytes of memory then on any write all 31 bytes must be
--   overwritten.</li>
--   <li>A single thread write/read sequence must always roundtrip</li>
--   <li>This is not a class for serialization, therefore memory layout of
--   unpacked datatype is selfcontained in <a>Prim</a> class and
--   representation is not expected to stay the same between different
--   versions of software. Primitive types like <a>Int</a>, <a>Word</a>,
--   <a>Char</a> are an exception to this rule for obvious reasons.</li>
--   </ul>
class Prim a
newtype Atom a
Atom :: a -> Atom a
[unAtom] :: Atom a -> a
class (Prim a, Eq a) => Atomic a
class Atomic a => AtomicCount a
class (Bits a, Atomic a) => AtomicBits a
class MonadThrow m => MonadPrim s m | m -> s

-- | A shorter synonym for the magical <a>RealWorld</a>
type RW = RealWorld

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

-- | The strict <a>ST</a> monad. The <a>ST</a> monad allows for destructive
--   updates, but is escapable (unlike IO). A computation of type
--   <tt><a>ST</a> s a</tt> returns a value of type <tt>a</tt>, and execute
--   in "thread" <tt>s</tt>. The <tt>s</tt> parameter is either
--   
--   <ul>
--   <li>an uninstantiated type variable (inside invocations of
--   <a>runST</a>), or</li>
--   <li><a>RealWorld</a> (inside invocations of <a>stToIO</a>).</li>
--   </ul>
--   
--   It serves to keep the internal states of different invocations of
--   <a>runST</a> separate from each other and from invocations of
--   <a>stToIO</a>.
--   
--   The <a>&gt;&gt;=</a> and <a>&gt;&gt;</a> operations are strict in the
--   state (though not in values stored in the state). For example,
--   
--   <pre>
--   <a>runST</a> (writeSTRef _|_ v &gt;&gt;= f) = _|_
--   </pre>
data ST s a

-- | Return the value computed by a state thread. The <tt>forall</tt>
--   ensures that the internal state used by the <a>ST</a> computation is
--   inaccessible to the rest of the program.
runST :: (forall s. () => ST s a) -> a

-- | Helper function that converts a type into a string
showsType :: Typeable t => proxy t -> ShowS

-- | Get the size of the data type in bytes. Argument is not evaluated.
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Prim
--   
--   &gt;&gt;&gt; byteCount (Just 'a')
--   Count {unCount = 5}
--   </pre>
byteCount :: forall e. Prim e => e -> Count Word8

-- | Same as <tt>sizeOf</tt>, except that the type can be supplied as a
--   type level argument
--   
--   <pre>
--   &gt;&gt;&gt; :set -XTypeApplications
--   
--   &gt;&gt;&gt; import Data.Prim
--   
--   &gt;&gt;&gt; byteCountType @Int64
--   Count {unCount = 8}
--   </pre>
byteCountType :: forall e. Prim e => Count Word8

-- | Same as <a>byteCount</a>, but argument is a <a>Proxy</a> of
--   <tt>e</tt>, instead of the type itself.
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Prim
--   
--   &gt;&gt;&gt; import Data.Proxy
--   
--   &gt;&gt;&gt; byteCountProxy (Proxy :: Proxy Int64)
--   Count {unCount = 8}
--   </pre>
byteCountProxy :: forall proxy e. Prim e => proxy e -> Count Word8

-- | Get the alignemnt of the type in bytes. Argument is not evaluated.
alignment :: forall e. Prim e => e -> Int

-- | Same as <a>alignment</a>, except that the type can be supplied with
--   <tt>TypeApplications</tt>
--   
--   <pre>
--   &gt;&gt;&gt; :set -XTypeApplications
--   
--   &gt;&gt;&gt; import Data.Prim
--   
--   &gt;&gt;&gt; alignmentType @Int32
--   4
--   </pre>
alignmentType :: forall e. Prim e => Int

-- | Same as <a>alignment</a>, but argument is a <a>Proxy</a> of
--   <tt>a</tt>, instead of the type itself.
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Proxy
--   
--   &gt;&gt;&gt; alignmentProxy (Proxy :: Proxy Int64)
--   8
--   </pre>
alignmentProxy :: forall proxy e. Prim e => proxy e -> Int

-- | Number of elements
newtype Count e
Count :: Int -> Count e
[unCount] :: Count e -> Int

-- | Covert an element count to number of bytes it coresponds to as an
--   <a>Int</a>. See <a>toByteCount</a> for preserving the <a>Count</a>
--   wrapper.
unCountBytes :: Prim e => Count e -> Int

-- | Covert to the <a>Count</a> of bytes
toByteCount :: Prim e => Count e -> Count Word8
unCountBytes# :: Prim e => Count e -> Int#

-- | Compute how many elements of type <tt>e</tt> can fit in the supplied
--   number of bytes.
fromByteCount :: forall e. Prim e => Count Word8 -> Count e
fromByteCountRem :: forall e. Prim e => Count Word8 -> (Count e, Count Word8)

-- | Cast a count to an offset of the same type
countToOff :: Count e -> Off e
countToByteOff :: Prim e => Count e -> Off Word8

-- | Restrict type argument of <a>Count</a> to the same type as the second
--   argument, which itself is not evaluated
countForType :: Count e -> e -> Count e

-- | Helper noop function that restricts <a>Count</a> to the type of proxy
countForProxyTypeOf :: Count e -> proxy e -> Count e

-- | Offset in number of elements
newtype Off e
Off :: Int -> Off e
[unOff] :: Off e -> Int

-- | Convert an offset for some type <tt>e</tt> with <a>Prim</a> instance
--   to the number of bytes as an <a>Int</a>.
--   
--   <pre>
--   &gt;&gt;&gt; unOffBytes (10 :: Off Word64)
--   80
--   </pre>
unOffBytes :: Prim e => Off e -> Int

-- | Compute byte offset from an offset of <a>Prim</a> type
--   
--   <pre>
--   &gt;&gt;&gt; toByteOff (10 :: Off Word64)
--   Off {unOff = 80}
--   </pre>
toByteOff :: Prim e => Off e -> Off Word8

-- | Convert offset of some type into number of bytes
unOffBytes# :: Prim e => Off e -> Int#
fromByteOff :: forall e. Prim e => Off Word8 -> Off e
fromByteOffRem :: forall e. Prim e => Off Word8 -> (Off e, Off Word8)

-- | Cast an offset to count. Useful for dealing with regions.
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Prim
--   
--   &gt;&gt;&gt; let totalCount = Count 10 :: Count Word
--   
--   &gt;&gt;&gt; let startOffset = Off 4 :: Off Word
--   
--   &gt;&gt;&gt; totalCount - offToCount startOffset
--   Count {unCount = 6}
--   </pre>
offToCount :: Off e -> Count e

-- | Convert an offset in elements to count in bytres.
offToByteCount :: Prim e => Off e -> Count Word8

-- | Restrict type argument of <a>Off</a> to the same type as the second
--   argument, which itself is not evaluated
offForType :: Off e -> e -> Off e

-- | Helper noop function that restricts <a>Off</a>set to the type of proxy
offForProxyTypeOf :: Off e -> proxy e -> Off e
prefetchValue0 :: MonadPrim s m => a -> m ()
prefetchValue1 :: MonadPrim s m => a -> m ()
prefetchValue2 :: MonadPrim s m => a -> m ()
prefetchValue3 :: MonadPrim s m => a -> m ()

-- | A value of type <tt><a>Ptr</a> a</tt> represents a pointer to an
--   object, or an array of objects, which may be marshalled to or from
--   Haskell values of type <tt>a</tt>.
--   
--   The type <tt>a</tt> will often be an instance of class <a>Storable</a>
--   which provides the marshalling operations. However this is not
--   essential, and you can provide your own operations to access the
--   pointer. For example you might write small foreign functions to get or
--   set the fields of a C <tt>struct</tt>.
data Ptr a

-- | The type <a>ForeignPtr</a> represents references to objects that are
--   maintained in a foreign language, i.e., that are not part of the data
--   structures usually managed by the Haskell storage manager. The
--   essential difference between <a>ForeignPtr</a>s and vanilla memory
--   references of type <tt>Ptr a</tt> is that the former may be associated
--   with <i>finalizers</i>. A finalizer is a routine that is invoked when
--   the Haskell storage manager detects that - within the Haskell heap and
--   stack - there are no more references left that are pointing to the
--   <a>ForeignPtr</a>. Typically, the finalizer will, then, invoke
--   routines in the foreign language that free the resources bound by the
--   foreign object.
--   
--   The <a>ForeignPtr</a> is parameterised in the same way as <a>Ptr</a>.
--   The type argument of <a>ForeignPtr</a> should normally be an instance
--   of class <a>Storable</a>.
data ForeignPtr a

-- | The class <a>Typeable</a> allows a concrete representation of a type
--   to be calculated.
class Typeable (a :: k)

-- | <a>Proxy</a> is a type that holds no data, but has a phantom parameter
--   of arbitrary type (or even kind). Its use is to provide type
--   information, even though there is no value available of that type (or
--   it may be too costly to create one).
--   
--   Historically, <tt><a>Proxy</a> :: <a>Proxy</a> a</tt> is a safer
--   alternative to the <tt><a>undefined</a> :: a</tt> idiom.
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy (Void, Int -&gt; Int)
--   Proxy
--   </pre>
--   
--   Proxy can even hold types of higher kinds,
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy Either
--   Proxy
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy Functor
--   Proxy
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy complicatedStructure
--   Proxy
--   </pre>
data Proxy (t :: k)
Proxy :: Proxy (t :: k)

-- | Coerce result of a function (it is also a hidden function in
--   Data.Functor.Utils)
(#.) :: forall a b c proxy. Coercible b c => proxy b c -> (a -> b) -> a -> c

-- | Coerce result of a function. Flipped version of <a>(#.)</a>
(.#) :: forall a b c proxy. Coercible b c => (a -> b) -> proxy b c -> a -> c

-- | The class of monoids (types with an associative binary operation that
--   has an identity). Instances should satisfy the following:
--   
--   <ul>
--   <li><i>Right identity</i> <tt>x <a>&lt;&gt;</a> <a>mempty</a> =
--   x</tt></li>
--   <li><i>Left identity</i> <tt><a>mempty</a> <a>&lt;&gt;</a> x =
--   x</tt></li>
--   <li><i>Associativity</i> <tt>x <a>&lt;&gt;</a> (y <a>&lt;&gt;</a> z) =
--   (x <a>&lt;&gt;</a> y) <a>&lt;&gt;</a> z</tt> (<a>Semigroup</a>
--   law)</li>
--   <li><i>Concatenation</i> <tt><a>mconcat</a> = <a>foldr</a>
--   (<a>&lt;&gt;</a>) <a>mempty</a></tt></li>
--   </ul>
--   
--   The method names refer to the monoid of lists under concatenation, but
--   there are many other instances.
--   
--   Some types can be viewed as a monoid in more than one way, e.g. both
--   addition and multiplication on numbers. In such cases we often define
--   <tt>newtype</tt>s and make those instances of <a>Monoid</a>, e.g.
--   <a>Sum</a> and <a>Product</a>.
--   
--   <b>NOTE</b>: <a>Semigroup</a> is a superclass of <a>Monoid</a> since
--   <i>base-4.11.0.0</i>.
class Semigroup a => Monoid a

-- | Identity of <a>mappend</a>
--   
--   <pre>
--   &gt;&gt;&gt; "Hello world" &lt;&gt; mempty
--   "Hello world"
--   </pre>
mempty :: Monoid a => a

-- | An associative operation
--   
--   <b>NOTE</b>: This method is redundant and has the default
--   implementation <tt><a>mappend</a> = (<a>&lt;&gt;</a>)</tt> since
--   <i>base-4.11.0.0</i>. Should it be implemented manually, since
--   <a>mappend</a> is a synonym for (<a>&lt;&gt;</a>), it is expected that
--   the two functions are defined the same way. In a future GHC release
--   <a>mappend</a> will be removed from <a>Monoid</a>.
mappend :: Monoid a => a -> a -> a

-- | Fold a list using the monoid.
--   
--   For most types, the default definition for <a>mconcat</a> will be
--   used, but the function is included in the class definition so that an
--   optimized version can be provided for specific types.
--   
--   <pre>
--   &gt;&gt;&gt; mconcat ["Hello", " ", "Haskell", "!"]
--   "Hello Haskell!"
--   </pre>
mconcat :: Monoid a => [a] -> a

-- | This data type witnesses the lifting of a <a>Monoid</a> into an
--   <a>Applicative</a> pointwise.
newtype Ap (f :: k -> Type) (a :: k)
Ap :: f a -> Ap (f :: k -> Type) (a :: k)
[getAp] :: Ap (f :: k -> Type) (a :: k) -> f a

-- | The dual of a <a>Monoid</a>, obtained by swapping the arguments of
--   <a>mappend</a>.
--   
--   <pre>
--   &gt;&gt;&gt; getDual (mappend (Dual "Hello") (Dual "World"))
--   "WorldHello"
--   </pre>
newtype Dual a
Dual :: a -> Dual a
[getDual] :: Dual a -> a

-- | The monoid of endomorphisms under composition.
--   
--   <pre>
--   &gt;&gt;&gt; let computation = Endo ("Hello, " ++) &lt;&gt; Endo (++ "!")
--   
--   &gt;&gt;&gt; appEndo computation "Haskell"
--   "Hello, Haskell!"
--   </pre>
newtype Endo a
Endo :: (a -> a) -> Endo a
[appEndo] :: Endo a -> a -> a

-- | Boolean monoid under conjunction (<a>&amp;&amp;</a>).
--   
--   <pre>
--   &gt;&gt;&gt; getAll (All True &lt;&gt; mempty &lt;&gt; All False)
--   False
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; getAll (mconcat (map (\x -&gt; All (even x)) [2,4,6,7,8]))
--   False
--   </pre>
newtype All
All :: Bool -> All
[getAll] :: All -> Bool

-- | Boolean monoid under disjunction (<a>||</a>).
--   
--   <pre>
--   &gt;&gt;&gt; getAny (Any True &lt;&gt; mempty &lt;&gt; Any False)
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; getAny (mconcat (map (\x -&gt; Any (even x)) [2,4,6,7,8]))
--   True
--   </pre>
newtype Any
Any :: Bool -> Any
[getAny] :: Any -> Bool

-- | Monoid under addition.
--   
--   <pre>
--   &gt;&gt;&gt; getSum (Sum 1 &lt;&gt; Sum 2 &lt;&gt; mempty)
--   3
--   </pre>
newtype Sum a
Sum :: a -> Sum a
[getSum] :: Sum a -> a

-- | Monoid under multiplication.
--   
--   <pre>
--   &gt;&gt;&gt; getProduct (Product 3 &lt;&gt; Product 4 &lt;&gt; mempty)
--   12
--   </pre>
newtype Product a
Product :: a -> Product a
[getProduct] :: Product a -> a

-- | Monoid under <a>&lt;|&gt;</a>.
--   
--   <pre>
--   &gt;&gt;&gt; getAlt (Alt (Just 12) &lt;&gt; Alt (Just 24))
--   Just 12
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; getAlt $ Alt Nothing &lt;&gt; Alt (Just 24)
--   Just 24
--   </pre>
newtype Alt (f :: k -> Type) (a :: k)
Alt :: f a -> Alt (f :: k -> Type) (a :: k)
[getAlt] :: Alt (f :: k -> Type) (a :: k) -> f a
instance Control.DeepSeq.NFData (Data.Prim.Count e)
instance GHC.Real.Real (Data.Prim.Count e)
instance GHC.Real.Integral (Data.Prim.Count e)
instance GHC.Num.Num (Data.Prim.Count e)
instance GHC.Enum.Bounded (Data.Prim.Count e)
instance GHC.Enum.Enum (Data.Prim.Count e)
instance GHC.Classes.Ord (Data.Prim.Count e)
instance GHC.Show.Show (Data.Prim.Count e)
instance GHC.Classes.Eq (Data.Prim.Count e)
instance Control.DeepSeq.NFData (Data.Prim.Off e)
instance GHC.Real.Real (Data.Prim.Off e)
instance GHC.Real.Integral (Data.Prim.Off e)
instance GHC.Num.Num (Data.Prim.Off e)
instance GHC.Enum.Bounded (Data.Prim.Off e)
instance GHC.Enum.Enum (Data.Prim.Off e)
instance GHC.Classes.Ord (Data.Prim.Off e)
instance GHC.Show.Show (Data.Prim.Off e)
instance GHC.Classes.Eq (Data.Prim.Off e)
instance Data.Prim.Class.Prim (Data.Prim.Off e)
instance Data.Prim.Class.Prim (Data.Prim.Count e)


module Data.Prim.Array
newtype Size
Size :: Int -> Size
[unSize] :: Size -> Int

-- | Immutable array with boxed elements.
data BArray e
BArray :: Array# e -> BArray e

-- | Compare pointers for two immutable arrays and see if they refer to the
--   exact same one.
isSameBArray :: BArray a -> BArray a -> Bool

-- | <i>O(1)</i> - Get the number of elements in an immutable array
--   
--   Documentation for utilized primop: <a>sizeofArray#</a>.
sizeOfBArray :: forall e. BArray e -> Size

-- | <i>O(1)</i> - Index an element in the immutable boxed array.
--   
--   Documentation for utilized primop: <a>indexArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> Bounds are not checked. When a precondition for
--   <tt>ix</tt> argument is violated the result is either unpredictable
--   output or failure with a segfault.</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Prim.Array
--   
--   &gt;&gt;&gt; let a = fromListBArray [[0 .. i] | i &lt;- [0 .. 10 :: Int]]
--   
--   &gt;&gt;&gt; indexBArray a 1
--   [0,1]
--   
--   &gt;&gt;&gt; indexBArray a 5
--   [0,1,2,3,4,5]
--   </pre>
indexBArray :: forall e. BArray e -> Int -> e

-- | <i>O(sz)</i> - Copy a subsection of an immutable array into a
--   subsection of a mutable array. Source and destination arrays must not
--   be the same array in different states.
--   
--   Documentation for utilized primop: <a>copyArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of the preconditions for
--   <tt>srcStartIx</tt>, <tt>dstStartIx</tt> or <tt>sz</tt> is violated
--   this function can result in a copy of some data that doesn't belong to
--   <tt>srcArray</tt> or more likely a failure with a segfault.</li>
--   </ul>
copyBArray :: forall e m s. MonadPrim s m => BArray e -> Int -> BMArray e s -> Int -> Size -> m ()

-- | <i>O(sz)</i> - Make an exact copy of a subsection of a pure immutable
--   array.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of the preconditions for <tt>startIx</tt>
--   or <tt>sz</tt> is violated this function can result in a copy of some
--   data that doesn't belong to <tt>srcArray</tt> or more likely a failure
--   with a segfault. Failure with out of memory is also possibility when
--   the @sz is too large.</li>
--   </ul>
--   
--   Documentation for utilized primop: <a>cloneArray#</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; let a = fromListBArray ['a'..'z']
--   
--   &gt;&gt;&gt; a
--   BArray "abcdefghijklmnopqrstuvwxyz"
--   
--   &gt;&gt;&gt; cloneBArray a 23 3
--   BArray "xyz"
--   </pre>
cloneBArray :: forall e. BArray e -> Int -> Size -> BArray e

-- | <i>O(1)</i> - Convert a pure immutable boxed array into a mutable
--   boxed array. Use <a>freezeBMArray</a> in order to go in the opposite
--   direction.
--   
--   Documentation for utilized primop: <a>unsafeThawArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> This function makes it possible to break referential
--   transparency, because any subsequent destructive operation to the
--   mutable boxed array will also be reflected in the source immutable
--   array as well. See <a>thawCopyBArray</a> that avoids this problem with
--   a fresh allocation and data copy.</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ma &lt;- thawBArray $ fromListBArray [1 .. 5 :: Integer]
--   
--   &gt;&gt;&gt; writeBMArray ma 1 10
--   
--   &gt;&gt;&gt; freezeBMArray ma
--   BArray [1,10,3,4,5]
--   </pre>
--   
--   Be careful not to retain a reference to the pure immutable source
--   array after the thawed version gets mutated.
--   
--   <pre>
--   &gt;&gt;&gt; let a = fromListBArray [1 .. 5 :: Integer]
--   
--   &gt;&gt;&gt; ma' &lt;- thawBArray a
--   
--   &gt;&gt;&gt; writeBMArray ma' 0 100000
--   
--   &gt;&gt;&gt; a
--   BArray [100000,2,3,4,5]
--   </pre>
thawBArray :: forall e m s. MonadPrim s m => BArray e -> m (BMArray e s)

-- | <i>O(sz)</i> - Create a new mutable array with size <tt>sz</tt> and
--   copy that number of elements from source immutable <tt>srcArray</tt>
--   starting at an offset <tt>startIx</tt> into the newly created
--   <tt>dstMutArray</tt>. This function can help avoid an issue with
--   referential transparency that is inherent to <a>thawBArray</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of the preconditions for <tt>startIx</tt>
--   or <tt>sz</tt> is violated this function can result in a copy of some
--   data that doesn't belong to <tt>srcArray</tt> or more likely a failure
--   with a segfault. Failure with out of memory is also a possibility when
--   the @sz is too large.</li>
--   </ul>
--   
--   Documentation for utilized primop: <a>thawArray#</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; let a = fromListBArray [1 .. 5 :: Int]
--   
--   &gt;&gt;&gt; ma &lt;- thawCopyBArray a 1 3
--   
--   &gt;&gt;&gt; writeBMArray ma 1 10
--   
--   &gt;&gt;&gt; freezeBMArray ma
--   BArray [2,10,4]
--   
--   &gt;&gt;&gt; a
--   BArray [1,2,3,4,5]
--   </pre>
thawCopyBArray :: forall e m s. MonadPrim s m => BArray e -> Int -> Size -> m (BMArray e s)

-- | Convert a pure boxed array into a list. It should work fine with GHC
--   built-in list fusion.
toListBArray :: forall e. BArray e -> [e]

-- | <i>O(length list)</i> - Convert a list into an immutable boxed array.
--   It is more efficient to use <a>fromListBArrayN</a> when the number of
--   elements is known ahead of time. The reason for this is that it is
--   necessary to iterate the whole list twice: once to count how many
--   elements there is in order to create large enough array that can fit
--   them; and the second time to load the actual elements. Naturally,
--   infinite lists will grind the program to a halt.
--   
--   <h4><b>Example</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; fromListBArray "Hello Haskell"
--   BArray "Hello Haskell"
--   </pre>
fromListBArray :: forall e. [e] -> BArray e

-- | <i>O(min(length list, sz))</i> - Same as <a>fromListBArray</a>, except
--   that it will allocate an array exactly of <tt>n</tt> size, as such it
--   will not convert any portion of the list that doesn't fit into the
--   newly created array.
--   
--   <ul>
--   <li><i>Partial</i> When length of supplied list is in fact smaller
--   then the expected size <tt>sz</tt>, thunks with
--   <a>UndefinedElement</a> exception throwing function will be placed in
--   the tail portion of the array.</li>
--   <li><i>Unsafe</i> When a precondition <tt>sz</tt> is violated this
--   function can result in critical failure with out of memory or
--   <a>HeapOverflow</a> async exception.</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; fromListBArrayN 3 [1 :: Int, 2, 3]
--   BArray [1,2,3]
--   
--   &gt;&gt;&gt; fromListBArrayN 3 [1 :: Int ..]
--   BArray [1,2,3]
--   </pre>
fromListBArrayN :: forall e. HasCallStack => Size -> [e] -> BArray e

-- | <i>O(1)</i> - cast a boxed immutable <a>Array</a> that is wired with
--   GHC to <a>BArray</a> from primal.
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Array.IArray as IA
--   
--   &gt;&gt;&gt; let arr = IA.listArray (10, 15) [30 .. 35] :: IA.Array Int Integer
--   
--   &gt;&gt;&gt; arr
--   array (10,15) [(10,30),(11,31),(12,32),(13,33),(14,34),(15,35)]
--   
--   &gt;&gt;&gt; fromBaseBArray arr
--   BArray [30,31,32,33,34,35]
--   </pre>
fromBaseBArray :: Array ix e -> BArray e

-- | <i>O(1)</i> - cast a boxed <a>BArray</a> from primal into
--   <a>Array</a>, which is wired with GHC. Resulting array range starts at
--   0, like any sane array would.
--   
--   <pre>
--   &gt;&gt;&gt; let arr = fromListBArray [1, 2, 3 :: Integer]
--   
--   &gt;&gt;&gt; arr
--   BArray [1,2,3]
--   
--   &gt;&gt;&gt; toBaseBArray arr
--   array (0,2) [(0,1),(1,2),(2,3)]
--   </pre>
toBaseBArray :: BArray e -> Array Int e

-- | Mutable array with boxed elements.
data BMArray e s
BMArray :: MutableArray# s e -> BMArray e s

-- | <i>O(1)</i> - Get the size of a mutable boxed array
--   
--   Documentation for utilized primop: <a>sizeofMutableArray#</a>.
--   
--   <h4><b>Example</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ma &lt;- newBMArray 1024 "Element of each cell"
--   
--   &gt;&gt;&gt; getSizeOfBMArray ma
--   Size {unSize = 1024}
--   </pre>
getSizeOfBMArray :: forall e m s. MonadPrim s m => BMArray e s -> m Size

-- | <i>O(1)</i> - Read an element from a mutable boxed array at the
--   supplied index.
--   
--   Documentation for utilized primop: <a>readArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> Violation of <tt>ix</tt> preconditions can result in
--   undefined behavior or a failure with a segfault</li>
--   </ul>
--   
--   <h4><b>Example</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ma &lt;- makeBMArray 10 (pure . ("Element ix: " ++) . show)
--   
--   &gt;&gt;&gt; readBMArray ma 5
--   "Element ix: 5"
--   </pre>
readBMArray :: forall e m s. MonadPrim s m => BMArray e s -> Int -> m e

-- | <i>O(1)</i> - Write an element <tt>elt</tt> into the mutable boxed
--   array <tt>dstMutArray</tt> at the supplied index <tt>ix</tt>. The
--   actual element will be evaluated to WHNF prior to mutation.
--   
--   <ul>
--   <li><i>Unsafe</i> Violation of <tt>ix</tt> preconditions can result in
--   heap corruption or a failure with a segfault</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ma &lt;- newBMArray 4 (Nothing :: Maybe Integer)
--   
--   &gt;&gt;&gt; writeBMArray ma 2 (Just 2)
--   
--   &gt;&gt;&gt; freezeBMArray ma
--   BArray [Nothing,Nothing,Just 2,Nothing]
--   </pre>
--   
--   It is important to note that an element is evaluated prior to being
--   written into a cell, so it will not overwrite the value of an array's
--   cell if it evaluates to an exception:
--   
--   <pre>
--   &gt;&gt;&gt; import Control.Prim.Exception
--   
--   &gt;&gt;&gt; writeBMArray ma 2 (impureThrow DivideByZero)
--   *** Exception: divide by zero
--   
--   &gt;&gt;&gt; freezeBMArray ma
--   BArray [Nothing,Nothing,Just 2,Nothing]
--   </pre>
--   
--   However, it is evaluated only to Weak Head Normal Form (WHNF), so it
--   is still possible to write something that eventually evaluates to
--   bottom.
--   
--   <pre>
--   &gt;&gt;&gt; writeBMArray ma 3 (Just (7 `div` 0 ))
--   
--   &gt;&gt;&gt; freezeBMArray ma
--   BArray [Nothing,Nothing,Just 2,Just *** Exception: divide by zero
--   
--   &gt;&gt;&gt; readBMArray ma 3
--   Just *** Exception: divide by zero
--   </pre>
--   
--   Either <a>deepseq</a> or <a>writeDeepBMArray</a> can be used to
--   alleviate that.
writeBMArray :: forall e m s. MonadPrim s m => BMArray e s -> Int -> e -> m ()

-- | <i>O(1)</i> - Same as <a>writeBMArray</a> but allows to write a thunk
--   into an array instead of an evaluated element. Careful with memory
--   leaks and thunks that evaluate to exceptions.
--   
--   Documentation for utilized primop: <a>writeArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> Same reasons as <a>writeBMArray</a></li>
--   </ul>
writeLazyBMArray :: forall e m s. MonadPrim s m => BMArray e s -> Int -> e -> m ()

-- | <i>O(1)</i> - Same as <a>writeBMArray</a>, except it ensures that the
--   value being written is fully evaluated, i.e. to Normal Form (NF).
--   
--   <ul>
--   <li><i>Unsafe</i> Same reasons as <a>writeBMArray</a></li>
--   </ul>
writeDeepBMArray :: forall e m s. (MonadPrim s m, NFData e) => BMArray e s -> Int -> e -> m ()

-- | Compare pointers for two mutable arrays and see if they refer to the
--   exact same one.
--   
--   Documentation for utilized primop: <a>sameMutableArray#</a>.
isSameBMArray :: forall a s. BMArray a s -> BMArray a s -> Bool

-- | Create a mutable boxed array where each element is set to the supplied
--   initial value <tt>elt</tt>, which is evaluated before array allocation
--   happens. See <a>newLazyBMArray</a> for an ability to initialize with a
--   thunk.
--   
--   <ul>
--   <li><i>Unsafe size</i> Violation of precondition for the <tt>sz</tt>
--   argument can result in the current thread being killed with
--   <a>HeapOverflow</a> asynchronous exception or death of the whole
--   process with some unchecked exception from RTS.</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; newBMArray 10 'A' &gt;&gt;= freezeBMArray
--   BArray "AAAAAAAAAA"
--   </pre>
newBMArray :: forall e m s. MonadPrim s m => Size -> e -> m (BMArray e s)

-- | Same as <a>newBMArray</a>, except initial element is allowed to be a
--   thunk.
--   
--   Documentation for utilized primop: <a>newArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> Same reasons as <a>newBMArray</a></li>
--   </ul>
newLazyBMArray :: forall e m s. MonadPrim s m => Size -> e -> m (BMArray e s)

-- | Create new mutable array, where each element is initilized to a thunk
--   that throws an error when evaluated. This is useful when there is a
--   plan to later iterate over the whole array and write values into each
--   cell in some index aware fashion. Consider <a>makeBMArray</a> as an
--   alternative.
--   
--   <ul>
--   <li><i>Partial</i> All array cells are initialized with thunks that
--   throw <a>UndefinedElement</a> exception when evaluated</li>
--   <li><i>Unsafe</i> Same reasons as <a>newBMArray</a></li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Prim
--   
--   &gt;&gt;&gt; let xs = "Hello Haskell"
--   
--   &gt;&gt;&gt; ma &lt;- newRawBMArray (Size (length xs)) :: IO (BMArray Char RW)
--   
--   &gt;&gt;&gt; mapM_ (\(i, x) -&gt; writeBMArray ma i x) (zip [0..] xs)
--   
--   &gt;&gt;&gt; freezeBMArray ma
--   BArray "Hello Haskell"
--   </pre>
newRawBMArray :: forall e m s. (HasCallStack, MonadPrim s m) => Size -> m (BMArray e s)

-- | Create new mutable boxed array of the supplied size and fill it with a
--   monadic action that is applied to indices of each array cell.
--   
--   <ul>
--   <li><i>Unsafe</i> Same reasons as <a>newBMArray</a></li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ma &lt;- makeBMArray 5 $ \i -&gt; (toEnum (i + 97) :: Char) &lt;$ putStrLn ("Handling index: " ++ show i)
--   Handling index: 0
--   Handling index: 1
--   Handling index: 2
--   Handling index: 3
--   Handling index: 4
--   
--   &gt;&gt;&gt; freezeBMArray ma
--   BArray "abcde"
--   </pre>
makeBMArray :: forall e m s. MonadPrim s m => Size -> (Int -> m e) -> m (BMArray e s)

-- | <i>O(sz)</i> - Copy a subsection of a mutable array into a subsection
--   of another or the same mutable array. Therefore, unlike
--   <a>copyBArray</a>, memory ia allowed to overlap between source and
--   destination.
--   
--   Documentation for utilized primop: <a>copyMutableArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of the preconditions for
--   <tt>srcStartIx</tt>, <tt>dstStartIx</tt> or <tt>sz</tt> is violated
--   this function can result in a copy of some data that doesn't belong to
--   <tt>srcArray</tt> or more likely a failure with a segfault.</li>
--   </ul>
moveBMArray :: forall e m s. MonadPrim s m => BMArray e s -> Int -> BMArray e s -> Int -> Size -> m ()

-- | <i>O(sz)</i> - Allocate a new mutable array of size <tt>sz</tt> and
--   copy that number of the elements over from the <tt>srcArray</tt>
--   starting at index <tt>ix</tt>. Similar to <a>cloneBArray</a>, except
--   it works on mutable arrays.
--   
--   Documentation for utilized primop: <a>cloneMutableArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of the preconditions for <tt>startIx</tt>
--   or <tt>sz</tt> is violated this function can result in a copy of some
--   data that doesn't belong to <tt>srcArray</tt> or more likely a failure
--   with a segfault. Failure with out of memory is also a possibility when
--   the @sz is too large.</li>
--   </ul>
cloneBMArray :: forall e m s. MonadPrim s m => BMArray e s -> Int -> Size -> m (BMArray e s)

-- | <i>O(1)</i> - Reduce the size of a mutable boxed array.
--   
--   Documentation for utilized primop: <a>shrinkMutableArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> - Violation of preconditions for <tt>sz</tt> leads
--   to undefined behavior</li>
--   </ul>
--   
--   <ol>
--   <li>3.0</li>
--   </ol>
shrinkBMArray :: forall e m s. MonadPrim s m => BMArray e s -> Size -> m ()

-- | <i>O(1)</i> - Either grow or shrink the size of a mutable unboxed
--   array. Shrinking happens in-place without new array creation and data
--   copy, while growing the array is implemented with creating new array
--   and copy of the data over from the source array <tt>srcMutArray</tt>.
--   This has a consequence that produced array <tt>dstMutArray</tt> might
--   refer to the same <tt>srcMutArray</tt> or to a totally new array,
--   which can be checked with <a>isSameBMArray</a>.
--   
--   Documentation on the utilized primop: <a>resizeMutableArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> - Same reasons as in <a>newRawBMArray</a>.</li>
--   </ul>
--   
--   <ol>
--   <li>3.0</li>
--   </ol>
resizeBMArray :: forall e m s. MonadPrim s m => BMArray e s -> Size -> e -> m (BMArray e s)

-- | <i>O(1)</i> - Same as <a>resizeBMArray</a>, except when growing the
--   array empty space at the end is filled with bottom.
--   
--   <ul>
--   <li><i>Partial</i> - When size <tt>sz</tt> is larger then the size of
--   <tt>srcMutArray</tt> then <tt>dstMutArray</tt> will have cells at the
--   end initialized with thunks that throw <a>UndefinedElement</a>
--   exception.</li>
--   <li><i>Unsafe</i> - Same reasons as in <a>newBMArray</a>.</li>
--   </ul>
--   
--   <ol>
--   <li>3.0</li>
--   </ol>
resizeRawBMArray :: forall e m s. MonadPrim s m => BMArray e s -> Size -> m (BMArray e s)

-- | <i>O(1)</i> - Convert a mutable boxed array into an immutable one. Use
--   <a>thawBArray</a> in order to go in the opposite direction.
--   
--   Documentation for utilized primop: <a>unsafeFreezeArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> This function makes it possible to break referential
--   transparency, because any subsequent destructive operation to the
--   source mutable boxed array will also be reflected in the resulting
--   immutable array. See <a>freezeCopyBMArray</a> that avoids this problem
--   with fresh allocation.</li>
--   </ul>
freezeBMArray :: forall e m s. MonadPrim s m => BMArray e s -> m (BArray e)

-- | <i>O(sz)</i> - Similar to <a>freezeBMArray</a>, except it creates a
--   new array with the copy of a subsection of a mutable array before
--   converting it into an immutable.
--   
--   Documentation for utilized primop: <a>freezeArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of the preconditions for <tt>startIx</tt>
--   or <tt>sz</tt> is violated this function can result in a copy of some
--   data that doesn't belong to <tt>srcArray</tt> or more likely a failure
--   with a segfault or out of memory exception.</li>
--   </ul>
freezeCopyBMArray :: forall e m s. MonadPrim s m => BMArray e s -> Int -> Size -> m (BArray e)

-- | Small boxed immutable array
data SBArray e
SBArray :: SmallArray# e -> SBArray e

-- | Compare pointers for two immutable arrays and see if they refer to the
--   exact same one.
isSameSBArray :: SBArray a -> SBArray a -> Bool

-- | <i>O(1)</i> - Get the number of elements in an immutable array
--   
--   Documentation for utilized primop: <a>sizeofSmallArray#</a>.
sizeOfSBArray :: forall e. SBArray e -> Size

-- | <i>O(1)</i> - Index an element in the immutable small boxed array.
--   
--   Documentation for utilized primop: <a>indexSmallArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> Bounds are not checked. When a precondition for
--   <tt>ix</tt> argument is violated the result is either unpredictable
--   output or failure with a segfault.</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Prim.Array
--   
--   &gt;&gt;&gt; let a = fromListSBArray [[0 .. i] | i &lt;- [0 .. 10 :: Int]]
--   
--   &gt;&gt;&gt; indexSBArray a 1
--   [0,1]
--   
--   &gt;&gt;&gt; indexSBArray a 5
--   [0,1,2,3,4,5]
--   </pre>
indexSBArray :: forall e. SBArray e -> Int -> e

-- | <i>O(sz)</i> - Copy a subsection of an immutable array into a
--   subsection of a mutable array. Source and destination arrays must not
--   be the same array in different states.
--   
--   Documentation for utilized primop: <a>copySmallArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of the preconditions for
--   <tt>srcStartIx</tt>, <tt>dstStartIx</tt> or <tt>sz</tt> is violated
--   this function can result in a copy of some data that doesn't belong to
--   <tt>srcArray</tt> or more likely a failure with a segfault.</li>
--   </ul>
copySBArray :: forall e m s. MonadPrim s m => SBArray e -> Int -> SBMArray e s -> Int -> Size -> m ()

-- | <i>O(sz)</i> - Make an exact copy of a subsection of a pure immutable
--   array.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of the preconditions for <tt>startIx</tt>
--   or <tt>sz</tt> is violated this function can result in a copy of some
--   data that doesn't belong to <tt>srcArray</tt> or more likely a failure
--   with a segfault. Failure with out of memory is also a possibility when
--   the @sz is too large.</li>
--   </ul>
--   
--   Documentation for utilized primop: <a>cloneSmallArray#</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; let a = fromListSBArray ['a'..'z']
--   
--   &gt;&gt;&gt; a
--   SBArray "abcdefghijklmnopqrstuvwxyz"
--   
--   &gt;&gt;&gt; cloneSBArray a 23 3
--   SBArray "xyz"
--   </pre>
cloneSBArray :: forall e. SBArray e -> Int -> Size -> SBArray e

-- | <i>O(1)</i> - Convert a pure immutable boxed array into a mutable
--   boxed array. Use <a>freezeSBMArray</a> in order to go in the opposite
--   direction.
--   
--   Documentation for utilized primop: <a>unsafeThawSmallArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> This function makes it possible to break referential
--   transparency, because any subsequent destructive operation to the
--   mutable boxed array will also be reflected in the source immutable
--   array as well. See <a>thawCopySBArray</a> that avoids this problem
--   with a fresh allocation and data copy.</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ma &lt;- thawSBArray $ fromListSBArray [1 .. 5 :: Integer]
--   
--   &gt;&gt;&gt; writeSBMArray ma 1 10
--   
--   &gt;&gt;&gt; freezeSBMArray ma
--   SBArray [1,10,3,4,5]
--   </pre>
--   
--   Be careful not to retain a reference to the pure immutable source
--   array after the thawed version gets mutated.
--   
--   <pre>
--   &gt;&gt;&gt; let a = fromListSBArray [1 .. 5 :: Integer]
--   
--   &gt;&gt;&gt; ma' &lt;- thawSBArray a
--   
--   &gt;&gt;&gt; writeSBMArray ma' 0 100000
--   
--   &gt;&gt;&gt; a
--   SBArray [100000,2,3,4,5]
--   </pre>
thawSBArray :: forall e m s. MonadPrim s m => SBArray e -> m (SBMArray e s)

-- | <i>O(sz)</i> - Create a new mutable array with size <tt>sz</tt> and
--   copy that number of elements from source immutable <tt>srcArray</tt>
--   starting at an offset <tt>startIx</tt> into the newly created
--   <tt>dstMutArray</tt>. This function can help avoid an issue with
--   referential transparency that is inherent to <a>thawSBArray</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of the preconditions for <tt>startIx</tt>
--   or <tt>sz</tt> is violated this function can result in a copy of some
--   data that doesn't belong to <tt>srcArray</tt> or more likely a failure
--   with a segfault. Failure with out of memory is also a possibility when
--   the @sz is too large.</li>
--   </ul>
--   
--   Documentation for utilized primop: <a>thawSmallArray#</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; let a = fromListSBArray [1 .. 5 :: Int]
--   
--   &gt;&gt;&gt; ma &lt;- thawCopySBArray a 1 3
--   
--   &gt;&gt;&gt; writeSBMArray ma 1 10
--   
--   &gt;&gt;&gt; freezeSBMArray ma
--   SBArray [2,10,4]
--   
--   &gt;&gt;&gt; a
--   SBArray [1,2,3,4,5]
--   </pre>
thawCopySBArray :: forall e m s. MonadPrim s m => SBArray e -> Int -> Size -> m (SBMArray e s)

-- | Convert a pure boxed array into a list. It should work fine with GHC
--   built-in list fusion.
toListSBArray :: forall e. SBArray e -> [e]

-- | <i>O(length list)</i> - Convert a list into an immutable boxed array.
--   It is more efficient to use <a>fromListSBArrayN</a> when the number of
--   elements is known ahead of time. The reason for this is that it is
--   necessary to iterate the whole list twice: once to count how many
--   elements there is in order to create large enough array that can fit
--   them; and the second time to load the actual elements. Naturally,
--   infinite lists will grind the program to a halt.
--   
--   <h4><b>Example</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; fromListSBArray "Hello Haskell"
--   SBArray "Hello Haskell"
--   </pre>
fromListSBArray :: forall e. [e] -> SBArray e

-- | <i>O(min(length list, sz))</i> - Same as <a>fromListSBArray</a>,
--   except that it will allocate an array exactly of <tt>n</tt> size, as
--   such it will not convert any portion of the list that doesn't fit into
--   the newly created array.
--   
--   <ul>
--   <li><i>Partial</i> When length of supplied list is in fact smaller
--   then the expected size <tt>sz</tt>, thunks with
--   <a>UndefinedElement</a> exception throwing function will be placed in
--   the tail portion of the array.</li>
--   <li><i>Unsafe</i> When a precondition <tt>sz</tt> is violated this
--   function can result in critical failure with out of memory or
--   <a>HeapOverflow</a> async exception.</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; fromListSBArrayN 3 [1 :: Int, 2, 3]
--   SBArray [1,2,3]
--   
--   &gt;&gt;&gt; fromListSBArrayN 3 [1 :: Int ..]
--   SBArray [1,2,3]
--   </pre>
fromListSBArrayN :: forall e. HasCallStack => Size -> [e] -> SBArray e

-- | Small boxed mutable array
data SBMArray e s
SBMArray :: SmallMutableArray# s e -> SBMArray e s

-- | Compare pointers for two mutable arrays and see if they refer to the
--   exact same one.
--   
--   Documentation for utilized primop: <a>sameSmallMutableArray#</a>.
isSameSBMArray :: forall a s. SBMArray a s -> SBMArray a s -> Bool

-- | <i>O(1)</i> - Get the size of a mutable boxed array
--   
--   Documentation for utilized primop: <a>getSizeofSmallMutableArray#</a>
--   for ghc-8.10 and newer and fallback to <a>sizeofMutableArray#</a> for
--   older versions.
--   
--   <h4><b>Example</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ma &lt;- newSBMArray 1024 "Element of each cell"
--   
--   &gt;&gt;&gt; getSizeOfSBMArray ma
--   Size {unSize = 1024}
--   </pre>
getSizeOfSBMArray :: forall e m s. MonadPrim s m => SBMArray e s -> m Size

-- | <i>O(1)</i> - Read an element from a mutable small boxed array at the
--   supplied index.
--   
--   Documentation for utilized primop: <a>readSmallArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> Violation of <tt>ix</tt> preconditions can result in
--   undefined behavior or a failure with a segfault</li>
--   </ul>
--   
--   <h4><b>Example</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ma &lt;- makeSBMArray 10 (pure . ("Element ix: " ++) . show)
--   
--   &gt;&gt;&gt; readSBMArray ma 5
--   "Element ix: 5"
--   </pre>
readSBMArray :: forall e m s. MonadPrim s m => SBMArray e s -> Int -> m e

-- | <i>O(1)</i> - Write an element <tt>elt</tt> into the mutable small
--   boxed array <tt>dstMutArray</tt> at the supplied index <tt>ix</tt>.
--   The actual element will be evaluated to WHNF prior to mutation.
--   
--   <ul>
--   <li><i>Unsafe</i> Violation of <tt>ix</tt> preconditions can result in
--   heap corruption or a failure with a segfault</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ma &lt;- newSBMArray 4 (Nothing :: Maybe Integer)
--   
--   &gt;&gt;&gt; writeSBMArray ma 2 (Just 2)
--   
--   &gt;&gt;&gt; freezeSBMArray ma
--   SBArray [Nothing,Nothing,Just 2,Nothing]
--   </pre>
--   
--   It is important to note that an element is evaluated prior to being
--   written into a cell, so it will not overwrite the value of an array's
--   cell if it evaluates to an exception:
--   
--   <pre>
--   &gt;&gt;&gt; import Control.Prim.Exception
--   
--   &gt;&gt;&gt; writeSBMArray ma 2 (impureThrow DivideByZero)
--   *** Exception: divide by zero
--   
--   &gt;&gt;&gt; freezeSBMArray ma
--   SBArray [Nothing,Nothing,Just 2,Nothing]
--   </pre>
--   
--   However, it is evaluated only to Weak Head Normal Form (WHNF), so it
--   is still possible to write something that eventually evaluates to
--   bottom.
--   
--   <pre>
--   &gt;&gt;&gt; writeSBMArray ma 3 (Just (7 `div` 0 ))
--   
--   &gt;&gt;&gt; freezeSBMArray ma
--   SBArray [Nothing,Nothing,Just 2,Just *** Exception: divide by zero
--   </pre>
--   
--   Either <a>deepseq</a> or <a>writeDeepSBMArray</a> can be used to
--   alleviate that.
writeSBMArray :: forall e m s. MonadPrim s m => SBMArray e s -> Int -> e -> m ()

-- | <i>O(1)</i> - Same as <a>writeSBMArray</a> but allows to write a thunk
--   into an array instead of an evaluated element. Careful with memory
--   leaks and thunks that evaluate to exceptions.
--   
--   Documentation for utilized primop: <a>writeSmallArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> Same reasons as <a>writeSBMArray</a></li>
--   </ul>
writeLazySBMArray :: forall e m s. MonadPrim s m => SBMArray e s -> Int -> e -> m ()

-- | <i>O(1)</i> - Same as <a>writeSBMArray</a>, except it ensures that the
--   value being written is fully evaluated, i.e. to Normal Form (NF).
--   
--   <ul>
--   <li><i>Unsafe</i> Same reasons as <a>writeSBMArray</a></li>
--   </ul>
writeDeepSBMArray :: forall e m s. (MonadPrim s m, NFData e) => SBMArray e s -> Int -> e -> m ()

-- | Create a mutable boxed array where each element is set to the supplied
--   initial value <tt>elt</tt>, which is evaluated before array allocation
--   happens. See <a>newLazySBMArray</a> for an ability to initialize with
--   a thunk.
--   
--   <ul>
--   <li><i>Unsafe size</i> Violation of precondition for the <tt>sz</tt>
--   argument can result in the current thread being killed with
--   <a>HeapOverflow</a> asynchronous exception or death of the whole
--   process with some unchecked exception from RTS.</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; newSBMArray 10 'A' &gt;&gt;= freezeSBMArray
--   SBArray "AAAAAAAAAA"
--   </pre>
newSBMArray :: forall e m s. MonadPrim s m => Size -> e -> m (SBMArray e s)

-- | Same as <a>newSBMArray</a>, except initial element is allowed to be a
--   thunk.
--   
--   Documentation for utilized primop: <a>newSmallArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> Same reasons as <a>newSBMArray</a></li>
--   </ul>
newLazySBMArray :: forall e m s. MonadPrim s m => Size -> e -> m (SBMArray e s)

-- | Create new mutable array, where each element is initilized to a thunk
--   that throws an error when evaluated. This is useful when there is a
--   plan to later iterate over the whole array and write values into each
--   cell in some index aware fashion. Consider <a>makeSBMArray</a> as an
--   alternative.
--   
--   <ul>
--   <li><i>Partial</i> All array cells are initialized with thunks that
--   throw <a>UndefinedElement</a> exception.</li>
--   <li><i>Unsafe</i> Same reasons as <a>newSBMArray</a></li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Prim
--   
--   &gt;&gt;&gt; let xs = "Hello Haskell"
--   
--   &gt;&gt;&gt; ma &lt;- newRawSBMArray (Size (length xs)) :: IO (SBMArray Char RW)
--   
--   &gt;&gt;&gt; mapM_ (\(i, x) -&gt; writeSBMArray ma i x) (zip [0..] xs)
--   
--   &gt;&gt;&gt; freezeSBMArray ma
--   SBArray "Hello Haskell"
--   </pre>
newRawSBMArray :: forall e m s. (HasCallStack, MonadPrim s m) => Size -> m (SBMArray e s)

-- | Create new mutable boxed array of the supplied size and fill it with a
--   monadic action that is applied to indices of each array cell.
--   
--   <ul>
--   <li><i>Unsafe</i> Same reasons as <a>newSBMArray</a></li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ma &lt;- makeSBMArray 5 $ \i -&gt; (toEnum (i + 97) :: Char) &lt;$ putStrLn ("Handling index: " ++ show i)
--   Handling index: 0
--   Handling index: 1
--   Handling index: 2
--   Handling index: 3
--   Handling index: 4
--   
--   &gt;&gt;&gt; freezeSBMArray ma
--   SBArray "abcde"
--   </pre>
makeSBMArray :: forall e m s. MonadPrim s m => Size -> (Int -> m e) -> m (SBMArray e s)

-- | <i>O(sz)</i> - Copy a subsection of a mutable array into a subsection
--   of another or the same mutable array. Therefore, unlike
--   <a>copySBArray</a>, memory ia allowed to overlap between source and
--   destination.
--   
--   Documentation for utilized primop: <a>copySmallMutableArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of the preconditions for
--   <tt>srcStartIx</tt>, <tt>dstStartIx</tt> or <tt>sz</tt> is violated
--   this function can result in a copy of some data that doesn't belong to
--   <tt>srcArray</tt> or more likely a failure with a segfault.</li>
--   </ul>
moveSBMArray :: forall e m s. MonadPrim s m => SBMArray e s -> Int -> SBMArray e s -> Int -> Size -> m ()

-- | <i>O(sz)</i> - Allocate a new small boxed mutable array of size
--   <tt>sz</tt> and copy that number of the elements over from the
--   <tt>srcArray</tt> starting at index <tt>ix</tt>. Similar to
--   <a>cloneSBArray</a>, except that it works on mutable arrays.
--   
--   Documentation for utilized primop: <a>cloneSmallMutableArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of the preconditions for <tt>startIx</tt>
--   or <tt>sz</tt> is violated this function can result in a copy of some
--   data that doesn't belong to <tt>srcArray</tt> or more likely a failure
--   with a segfault. Failure with out of memory is also a possibility when
--   the @sz is too large.</li>
--   </ul>
cloneSBMArray :: forall e m s. MonadPrim s m => SBMArray e s -> Int -> Size -> m (SBMArray e s)

-- | <i>O(1)</i> - Reduce the size of a mutable small boxed array.
--   
--   Documentation for utilized primop: <a>shrinkSmallMutableArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> - Violation of preconditions for <tt>sz</tt> leads
--   to undefined behavior</li>
--   </ul>
--   
--   <ol>
--   <li>3.0</li>
--   </ol>
shrinkSBMArray :: forall e m s. MonadPrim s m => SBMArray e s -> Size -> m ()

-- | <i>O(1)</i> - Either grow or shrink the size of a mutable unboxed
--   array. Shrinking happens in-place without new array creation and data
--   copy, while growing the array is implemented with creating new array
--   and copy of the data over from the source array <tt>srcMutArray</tt>.
--   This has a consequence that produced array <tt>dstMutArray</tt> might
--   refer to the same <tt>srcMutArray</tt> or to a totally new array,
--   which can be checked with <a>isSameSBMArray</a>.
--   
--   Documentation on the utilized primop: <a>resizeSmallMutableArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> - Same reasons as in <a>newRawSBMArray</a>.</li>
--   </ul>
--   
--   <ol>
--   <li>3.0</li>
--   </ol>
resizeSBMArray :: forall e m s. MonadPrim s m => SBMArray e s -> Size -> e -> m (SBMArray e s)

-- | <i>O(1)</i> - Same as <a>resizeSBMArray</a>, except when growing the
--   array empty space at the end is filled with bottom.
--   
--   <ul>
--   <li><i>Partial</i> - When size <tt>sz</tt> is larger then the size of
--   <tt>srcMutArray</tt> then <tt>dstMutArray</tt> will have cells at the
--   end initialized with thunks that throw <a>UndefinedElement</a>
--   exception.</li>
--   <li><i>Unsafe</i> - Same reasons as in <a>newSBMArray</a>.</li>
--   </ul>
--   
--   <ol>
--   <li>3.0</li>
--   </ol>
resizeRawSBMArray :: forall e m s. MonadPrim s m => SBMArray e s -> Size -> m (SBMArray e s)

-- | <i>O(1)</i> - Convert a mutable boxed array into an immutable one. Use
--   <a>thawSBArray</a> in order to go in the opposite direction.
--   
--   Documentation for utilized primop: <a>unsafeFreezeSmallArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> This function makes it possible to break referential
--   transparency, because any subsequent destructive operation to the
--   source mutable boxed array will also be reflected in the resulting
--   immutable array. See <a>freezeCopySBMArray</a> that avoids this
--   problem with fresh allocation.</li>
--   </ul>
freezeSBMArray :: forall e m s. MonadPrim s m => SBMArray e s -> m (SBArray e)

-- | <i>O(sz)</i> - Similar to <a>freezeSBMArray</a>, except it creates a
--   new array with the copy of a subsection of a mutable array before
--   converting it into an immutable.
--   
--   Documentation for utilized primop: <a>freezeSmallArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of the preconditions for <tt>startIx</tt>
--   or <tt>sz</tt> is violated this function can result in a copy of some
--   data that doesn't belong to <tt>srcArray</tt> or more likely a failure
--   with a segfault or out of memory exception.</li>
--   </ul>
freezeCopySBMArray :: forall e m s. MonadPrim s m => SBMArray e s -> Int -> Size -> m (SBArray e)
data UArray e
UArray :: ByteArray# -> UArray e

-- | <i>O(1)</i> - Compare pointers for two immutable arrays and see if
--   they refer to the exact same one.
--   
--   Documentation for utilized primop: <a>isSameByteArray#</a>.
isSameUArray :: forall a b. UArray a -> UArray b -> Bool

-- | <i>O(1)</i> - Check if memory for immutable unboxed array was
--   allocated as pinned.
--   
--   Documentation for utilized primop: <a>isByteArrayPinned#</a>.
isPinnedUArray :: forall e. UArray e -> Bool

-- | <i>O(1)</i> - Get the size of an immutable array in number of
--   elements.
--   
--   Documentation for utilized primop: <a>sizeofByteArray#</a>.
sizeOfUArray :: forall e. Prim e => UArray e -> Size

-- | <i>O(1)</i> - Index an element of a pure unboxed array.
--   
--   Documentation for utilized primop: <a>indexByteArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> Bounds are not checked. When a precondition for
--   <tt>ix</tt> argument is violated the result is either unpredictable
--   output or failure with a segfault.</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; let a = fromListUArray ([Left pi, Right 123] :: [Either Double Int])
--   
--   &gt;&gt;&gt; indexUArray a 0
--   Left 3.141592653589793
--   
--   &gt;&gt;&gt; indexUArray a 1
--   Right 123
--   </pre>
indexUArray :: forall e. Prim e => UArray e -> Int -> e

-- | <i>O(sz)</i> - Copy a subsection of an immutable array into a
--   subsection of another mutable array. Source and destination arrays
--   must not be the same array in different states.
--   
--   Documentation for utilized primop: <a>copyByteArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of the preconditions for
--   <tt>srcStartIx</tt>, <tt>dstStartIx</tt> or <tt>sz</tt> is violated
--   this function can result in a copy of some data that doesn't belong to
--   <tt>srcArray</tt> or failure with a segfault.</li>
--   </ul>
copyUArray :: forall e m s. (Prim e, MonadPrim s m) => UArray e -> Int -> UMArray e s -> Int -> Size -> m ()

-- | <i>O(1)</i> - Convert a pure immutable unboxed array into a mutable
--   unboxed array. Use <a>freezeUMArray</a> in order to go in the opposite
--   direction.
--   
--   Documentation for utilized primop: <a>unsafeThawByteArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> This function makes it possible to break referential
--   transparency, because any subsequent destructive operation to the
--   mutable unboxed array will also be reflected in the source immutable
--   array as well.</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ma &lt;- thawUArray $ fromListUArray [1 .. 5 :: Int]
--   
--   &gt;&gt;&gt; writeUMArray ma 1 10
--   
--   &gt;&gt;&gt; freezeUMArray ma
--   UArray [1,10,3,4,5]
--   </pre>
--   
--   Be careful not to retain a reference to the pure immutable source
--   array after the thawed version gets mutated.
--   
--   <pre>
--   &gt;&gt;&gt; let a = fromListUArray [1 .. 5 :: Int]
--   
--   &gt;&gt;&gt; ma' &lt;- thawUArray a
--   
--   &gt;&gt;&gt; writeUMArray ma' 0 100000
--   
--   &gt;&gt;&gt; a
--   UArray [100000,2,3,4,5]
--   </pre>
thawUArray :: forall e m s. MonadPrim s m => UArray e -> m (UMArray e s)

-- | <i>O(n)</i> - Convert a pure boxed array into a list. It should work
--   fine with GHC built-in list fusion.
toListUArray :: forall e. Prim e => UArray e -> [e]

-- | <i>O(length list)</i> - Convert a list into an immutable boxed array.
--   It is more efficient to use <a>fromListUArrayN</a> when the number of
--   elements is known ahead of time. The reason for this is that it is
--   necessary to iterate the whole list twice: once to count how many
--   elements there is in order to create large enough array that can fit
--   them; and the second time to load the actual elements. Naturally,
--   infinite lists will grind the program to a halt.
--   
--   <h4><b>Example</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; fromListUArray "Hello Haskell"
--   UArray "Hello Haskell"
--   </pre>
fromListUArray :: forall e. Prim e => [e] -> UArray e

-- | <i>O(min(length list, sz))</i> - Same as <a>fromListUArray</a>, except
--   it will allocate an array exactly of <tt>n</tt> size, as such it will
--   not convert any portion of the list that doesn't fit into the newly
--   created array.
--   
--   <ul>
--   <li><i>Partial</i> When length of supplied list is in fact smaller
--   then the expected size <tt>sz</tt>, thunks with
--   <a>UndefinedElement</a> exception throwing function will be placed in
--   the tail portion of the array.</li>
--   <li><i>Unsafe</i> When a precondition <tt>sz</tt> is violated this
--   function can result in critical failure with out of memory or
--   <a>HeapOverflow</a> async exception.</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; fromListUArrayN 3 [1 :: Int, 2, 3]
--   UArray [1,2,3]
--   
--   &gt;&gt;&gt; fromListUArrayN 3 [1 :: Int ..]
--   UArray [1,2,3]
--   </pre>
fromListUArrayN :: forall e. Prim e => Size -> [e] -> UArray e

-- | <i>O(1)</i> - cast an unboxed <a>UArray</a> that is wired with GHC to
--   <a>UArray</a> from primal.
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Array.IArray as IA
--   
--   &gt;&gt;&gt; import Data.Array.Unboxed as UA
--   
--   &gt;&gt;&gt; let uarr = IA.listArray (10, 15) [30 .. 35] :: UA.UArray Int Word
--   
--   &gt;&gt;&gt; uarr
--   array (10,15) [(10,30),(11,31),(12,32),(13,33),(14,34),(15,35)]
--   
--   &gt;&gt;&gt; fromBaseUArray uarr
--   UArray [30,31,32,33,34,35]
--   </pre>
fromBaseUArray :: (Prim e, IArray UArray e) => UArray ix e -> UArray e

-- | <i>O(1)</i> - cast an unboxed <a>UArray</a> from primal into
--   <a>UArray</a>, which is wired with GHC. Resulting array range starts
--   at 0, like any sane array would.
--   
--   <pre>
--   &gt;&gt;&gt; let uarr = fromListUArray [1, 2, 3 :: Int]
--   
--   &gt;&gt;&gt; uarr
--   UArray [1,2,3]
--   
--   &gt;&gt;&gt; toBaseUArray uarr
--   array (0,2) [(0,1),(1,2),(2,3)]
--   </pre>
toBaseUArray :: (Prim e, IArray UArray e) => UArray e -> UArray Int e
data UMArray e s
UMArray :: MutableByteArray# s -> UMArray e s

-- | <i>O(1)</i> - Compare pointers for two mutable arrays and see if they
--   refer to the exact same one.
--   
--   Documentation for utilized primop: <a>sameMutableByteArray#</a>.
isSameUMArray :: forall a b s. UMArray a s -> UMArray b s -> Bool

-- | <i>O(1)</i> - Check if memory for mutable unboxed array was allocated
--   as pinned.
--   
--   Documentation for utilized primop: <a>isMutableByteArrayPinned#</a>.
isPinnedUMArray :: forall e s. UMArray e s -> Bool

-- | <i>O(1)</i> - Get the size of a mutable unboxed array
--   
--   Documentation for utilized primop: <a>getSizeofMutableByteArray#</a>.
--   
--   <h4><b>Example</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ma &lt;- thawUArray $ fromListUArray ['a' .. 'z']
--   
--   &gt;&gt;&gt; getSizeOfUMArray ma
--   Size {unSize = 26}
--   </pre>
getSizeOfUMArray :: forall e m s. (Prim e, MonadPrim s m) => UMArray e s -> m Size

-- | <i>O(1)</i> - Read an element from a mutable unboxed array at the
--   supplied index.
--   
--   Documentation for utilized primop: <a>readMutableByteArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> Violation of <tt>ix</tt> preconditions can result in
--   value that doesn't belong to <tt>srcMutArray</tt> or a failure with a
--   segfault</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ma &lt;- thawUArray $ fromListUArray "Hi!"
--   
--   &gt;&gt;&gt; readUMArray ma 2
--   '!'
--   </pre>
readUMArray :: forall e m s. (Prim e, MonadPrim s m) => UMArray e s -> Int -> m e

-- | <i>O(1)</i> - Write an element into an unboxed mutable array at a
--   supplied index.
--   
--   Documentation for utilized primop: <a>writeMutableByteArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> Violation of <tt>ix</tt> preconditions can result in
--   heap corruption or a failure with a segfault</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Prim
--   
--   &gt;&gt;&gt; ma &lt;- newRawUMArray 4 :: IO (UMArray (Maybe Int) RW)
--   
--   &gt;&gt;&gt; mapM_ (\i -&gt; writeUMArray ma i Nothing) [0, 1, 3]
--   
--   &gt;&gt;&gt; writeUMArray ma 2 (Just 2)
--   
--   &gt;&gt;&gt; freezeUMArray ma
--   UArray [Nothing,Nothing,Just 2,Nothing]
--   </pre>
writeUMArray :: forall e m s. (Prim e, MonadPrim s m) => UMArray e s -> Int -> e -> m ()

-- | <i>O(sz)</i> - Allocate new mutable unboxed array. Similar to
--   <a>newRawUMArray</a>, except all elements are initialized to the
--   supplied initial value. This is equivalent to <tt>makeUMArray sz
--   (const (pure a))</tt> but often will be more efficient.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of preconditions for <tt>sz</tt> argument
--   is violated the outcome is unpredictable. One possible outcome is
--   termination with <a>HeapOverflow</a> async exception.</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Prim
--   
--   &gt;&gt;&gt; let xs = "Hello"
--   
--   &gt;&gt;&gt; ma &lt;- newUMArray (Size (length xs) + 8) '!' :: IO (UMArray Char RW)
--   
--   &gt;&gt;&gt; mapM_ (\(i, x) -&gt; writeUMArray ma i x) (zip [0..] xs)
--   
--   &gt;&gt;&gt; freezeUMArray ma
--   UArray "Hello!!!!!!!!"
--   </pre>
newUMArray :: forall e m s. (Prim e, MonadPrim s m) => Size -> e -> m (UMArray e s)

-- | <i>O(1)</i> - Allocate new mutable unboxed array. None of the elements
--   are initialized so expect it to contain some random garbage.
--   
--   Documentation for utilized primop: <a>newByteArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of preconditions for <tt>sz</tt> argument
--   is violated the outcome is unpredictable. One possible outcome is
--   termination with <a>HeapOverflow</a> async exception. In a pure
--   setting, such as when executed within <a>runST</a>, if each cell in
--   new array is not overwritten it can lead to violation of referential
--   transparency, because contents of newly allocated unboxed array is
--   non-determinstic.</li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Prim
--   
--   &gt;&gt;&gt; let xs = "Hello Haskell"
--   
--   &gt;&gt;&gt; ma &lt;- newRawUMArray (Size (length xs)) :: IO (UMArray Char RW)
--   
--   &gt;&gt;&gt; mapM_ (\(i, x) -&gt; writeUMArray ma i x) (zip [0..] xs)
--   
--   &gt;&gt;&gt; freezeUMArray ma
--   UArray "Hello Haskell"
--   </pre>
newRawUMArray :: forall e m s. (Prim e, MonadPrim s m) => Size -> m (UMArray e s)

-- | Create new mutable unboxed array of the supplied size and fill it with
--   a monadic action that is applied to indices of each array cell.
--   
--   <ul>
--   <li><i>Unsafe</i> Same reasons as <a>newUMArray</a></li>
--   </ul>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ma &lt;- makeUMArray 5 $ \i -&gt; (toEnum (i + 97) :: Char) &lt;$ putStrLn ("Handling index: " ++ show i)
--   Handling index: 0
--   Handling index: 1
--   Handling index: 2
--   Handling index: 3
--   Handling index: 4
--   
--   &gt;&gt;&gt; freezeUMArray ma
--   UArray "abcde"
--   </pre>
makeUMArray :: forall e m s. (Prim e, MonadPrim s m) => Size -> (Int -> m e) -> m (UMArray e s)

-- | Same <a>newUMArray</a>, but allocate memory as pinned. See
--   <a>newRawPinnedUMArray</a> for more info.
--   
--   <ul>
--   <li><i>Unsafe</i> - Same reasons as <a>newUMArray</a>.</li>
--   </ul>
newPinnedUMArray :: forall e m s. (Prim e, MonadPrim s m) => Size -> e -> m (UMArray e s)

-- | <i>O(1)</i> - Same as <a>newRawUMArray</a> except allocate new mutable
--   unboxed array as pinned
--   
--   Documentation for utilized primop: <a>newPinnedByteArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> Same reasons as in <a>newRawUMArray</a>.</li>
--   </ul>
newRawPinnedUMArray :: forall e m s. (Prim e, MonadPrim s m) => Size -> m (UMArray e s)

-- | Same as <a>makeUMArray</a>, but allocate memory as pinned.
--   
--   <ul>
--   <li><i>Unsafe</i> Same reasons as <a>newUMArray</a></li>
--   </ul>
makePinnedUMArray :: forall e m s. (Prim e, MonadPrim s m) => Size -> (Int -> m e) -> m (UMArray e s)

-- | Same <a>newUMArray</a>, but allocate memory as pinned and aligned. See
--   <a>newRawAlignedPinnedUMArray</a> for more info.
--   
--   <ul>
--   <li><i>Unsafe</i> - Same reasons as <a>newUMArray</a>.</li>
--   </ul>
newAlignedPinnedUMArray :: forall e m s. (Prim e, MonadPrim s m) => Size -> e -> m (UMArray e s)

-- | <i>O(1)</i> - Same as <a>newRawPinnedUMArray</a> except allocate new
--   mutable unboxed array as pinned and aligned according to the
--   <a>Prim</a> instance for the type of element <tt><b>e</b></tt>
--   
--   Documentation for utilized primop: <a>newAlignedPinnedByteArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> Same reasons as in <a>newRawUMArray</a>.</li>
--   </ul>
newRawAlignedPinnedUMArray :: forall e m s. (Prim e, MonadPrim s m) => Size -> m (UMArray e s)

-- | Same as <a>makeUMArray</a>, but allocate memory as pinned and aligned.
--   
--   <ul>
--   <li><i>Unsafe</i> Same reasons as <a>newUMArray</a></li>
--   </ul>
makeAlignedPinnedUMArray :: forall e m s. (Prim e, MonadPrim s m) => Size -> (Int -> m e) -> m (UMArray e s)

-- | <i>O(sz)</i> - Copy a subsection of a mutable array into a subsection
--   of another or the same mutable array. Therefore, unlike
--   <a>copyBArray</a>, memory ia allowed to overlap between source and
--   destination.
--   
--   Documentation for utilized primop: <a>copyMutableByteArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> When any of the preconditions for
--   <tt>srcStartIx</tt>, <tt>dstStartIx</tt> or <tt>sz</tt> is violated
--   this function can result in a copy of some data that doesn't belong to
--   <tt>srcArray</tt> or failure with a segfault.</li>
--   </ul>
moveUMArray :: forall e m s. (Prim e, MonadPrim s m) => UMArray e s -> Int -> UMArray e s -> Int -> Size -> m ()

-- | <i>O(n)</i> - Write the same element into the <tt>dstMutArray</tt>
--   mutable array <tt>n</tt> times starting at <tt>dstStartIx</tt> offset.
--   
--   <ul>
--   <li><i>Unsafe</i></li>
--   </ul>
setUMArray :: forall e m s. (Prim e, MonadPrim s m) => UMArray e s -> Int -> Size -> e -> m ()

-- | <i>O(1)</i> - Reduce the size of a mutable unboxed array.
--   
--   Documentation for utilized primop: <a>shrinkMutableByteArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> - Violation of preconditions for <tt>sz</tt> leads
--   to undefined behavior</li>
--   </ul>
--   
--   <ol>
--   <li>3.0</li>
--   </ol>
shrinkUMArray :: forall e m s. (MonadPrim s m, Prim e) => UMArray e s -> Size -> m ()

-- | <i>O(1)</i> - Either grow or shrink the size of a mutable unboxed
--   array. Shrinking happens without new allocation and data copy, while
--   growing the array is implemented with allocation of new unpinned array
--   and copy of the data over from the source array <tt>srcMutArray</tt>.
--   This has a consequence that produced array <tt>dstMutArray</tt> might
--   refer to the same <tt>srcMutArray</tt> or to a totally new array,
--   which can be checked with <a>isSameUMArray</a>.
--   
--   Documentation on the utilized primop: <a>resizeMutableByteArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> - Same reasons as in <a>newRawUMArray</a>. When size
--   <tt>sz</tt> is larger then the size of <tt>srcMutArray</tt> then
--   <tt>dstMutArray</tt> will contain uninitialized memory at its end,
--   hence a potential problem for referential transparency.</li>
--   </ul>
--   
--   <ol>
--   <li>3.0</li>
--   </ol>
resizeUMArray :: forall e m s. (MonadPrim s m, Prim e) => UMArray e s -> Size -> m (UMArray e s)

-- | <i>O(1)</i> - Convert a mutable unboxed array into an immutable one.
--   Use <a>thawUArray</a> in order to go in the opposite direction.
--   
--   Documentation on the utilized primop: <a>unsafeFreezeByteArray#</a>.
--   
--   <ul>
--   <li><i>Unsafe</i> This function makes it possible to break referential
--   transparency, because any subsequent destructive operation to the
--   source mutable boxed array will also be reflected in the resulting
--   immutable array. See <a>freezeCopyBMArray</a> that avoids this problem
--   with fresh allocation.</li>
--   </ul>
freezeUMArray :: forall e m s. MonadPrim s m => UMArray e s -> m (UArray e)

-- | Default "raw" element for boxed arrays.
uninitialized :: HasCallStack => String -> String -> a

-- | Helper for generating mutable arrays
makeMutWith :: Monad m => (Size -> m b) -> (b -> Int -> a -> m ()) -> Size -> (Int -> m a) -> m b

-- | Convert a list to a mutable array
fromListMutWith :: Monad m => (Size -> m b) -> (b -> Int -> a -> m ()) -> Size -> [a] -> m b

-- | Right fold that is strict on the element. The key feature of this
--   function is that it can be used to convert an array to a list by
--   integrating with list fusion using <a>build</a>.
foldrWithFB :: (a e -> Size) -> (a e -> Int -> e) -> (e -> b -> b) -> b -> a e -> b

-- | Check for equality of two arrays
eqWith :: Eq e => (a e -> a e -> Bool) -> (a e -> Size) -> (a e -> Int -> e) -> a e -> a e -> Bool

-- | Compare two arrays using supplied functions
compareWith :: Ord e => (a e -> a e -> Bool) -> (a e -> Size) -> (a e -> Int -> e) -> a e -> a e -> Ordering

-- | Append two arrays together using supplied functions
appendWith :: (forall s. Size -> ST s (ma e s)) -> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ()) -> (forall s. ma e s -> ST s (a e)) -> (a e -> Size) -> a e -> a e -> a e

-- | Concat many arrays together using supplied functions
concatWith :: (forall s. Size -> ST s (ma e s)) -> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ()) -> (forall s. ma e s -> ST s (a e)) -> (a e -> Size) -> [a e] -> a e
instance GHC.Enum.Enum Data.Prim.Array.Size
instance GHC.Enum.Bounded Data.Prim.Array.Size
instance GHC.Real.Integral Data.Prim.Array.Size
instance GHC.Real.Real Data.Prim.Array.Size
instance GHC.Num.Num Data.Prim.Array.Size
instance GHC.Classes.Ord Data.Prim.Array.Size
instance GHC.Classes.Eq Data.Prim.Array.Size
instance GHC.Show.Show Data.Prim.Array.Size
instance GHC.Classes.Eq (Data.Prim.Array.UMArray e s)
instance Control.DeepSeq.NFData (Data.Prim.Array.UMArray e s)
instance (Data.Prim.Class.Prim e, GHC.Show.Show e) => GHC.Show.Show (Data.Prim.Array.UArray e)
instance Data.Prim.Class.Prim e => GHC.Exts.IsList (Data.Prim.Array.UArray e)
instance (e GHC.Types.~ GHC.Types.Char) => Data.String.IsString (Data.Prim.Array.UArray e)
instance Control.DeepSeq.NFData (Data.Prim.Array.UArray e)
instance (Data.Prim.Class.Prim e, GHC.Classes.Eq e) => GHC.Classes.Eq (Data.Prim.Array.UArray e)
instance (Data.Prim.Class.Prim e, GHC.Classes.Ord e) => GHC.Classes.Ord (Data.Prim.Array.UArray e)
instance Data.Prim.Class.Prim e => GHC.Base.Semigroup (Data.Prim.Array.UArray e)
instance Data.Prim.Class.Prim e => GHC.Base.Monoid (Data.Prim.Array.UArray e)
instance GHC.Classes.Eq (Data.Prim.Array.SBMArray e s)
instance GHC.Base.Functor Data.Prim.Array.SBArray
instance Data.Foldable.Foldable Data.Prim.Array.SBArray
instance Data.Functor.Classes.Show1 Data.Prim.Array.SBArray
instance GHC.Show.Show e => GHC.Show.Show (Data.Prim.Array.SBArray e)
instance GHC.Exts.IsList (Data.Prim.Array.SBArray e)
instance (e GHC.Types.~ GHC.Types.Char) => Data.String.IsString (Data.Prim.Array.SBArray e)
instance Control.DeepSeq.NFData e => Control.DeepSeq.NFData (Data.Prim.Array.SBArray e)
instance GHC.Classes.Eq e => GHC.Classes.Eq (Data.Prim.Array.SBArray e)
instance GHC.Classes.Ord e => GHC.Classes.Ord (Data.Prim.Array.SBArray e)
instance Data.Functor.Classes.Eq1 Data.Prim.Array.SBArray
instance Data.Functor.Classes.Ord1 Data.Prim.Array.SBArray
instance GHC.Base.Semigroup (Data.Prim.Array.SBArray e)
instance GHC.Base.Monoid (Data.Prim.Array.SBArray e)
instance GHC.Classes.Eq (Data.Prim.Array.BMArray e s)
instance GHC.Base.Functor Data.Prim.Array.BArray
instance Data.Foldable.Foldable Data.Prim.Array.BArray
instance Data.Functor.Classes.Show1 Data.Prim.Array.BArray
instance GHC.Show.Show e => GHC.Show.Show (Data.Prim.Array.BArray e)
instance GHC.Exts.IsList (Data.Prim.Array.BArray e)
instance (e GHC.Types.~ GHC.Types.Char) => Data.String.IsString (Data.Prim.Array.BArray e)
instance Control.DeepSeq.NFData e => Control.DeepSeq.NFData (Data.Prim.Array.BArray e)
instance GHC.Classes.Eq e => GHC.Classes.Eq (Data.Prim.Array.BArray e)
instance GHC.Classes.Ord e => GHC.Classes.Ord (Data.Prim.Array.BArray e)
instance Data.Functor.Classes.Eq1 Data.Prim.Array.BArray
instance Data.Functor.Classes.Ord1 Data.Prim.Array.BArray
instance GHC.Base.Semigroup (Data.Prim.Array.BArray e)
instance GHC.Base.Monoid (Data.Prim.Array.BArray e)
instance Data.Prim.Class.Prim Data.Prim.Array.Size


module Foreign.Prim.Ptr
plusOffPtr :: Prim e => Ptr e -> Off e -> Ptr e
plusByteOffPtr :: Ptr e -> Off Word8 -> Ptr e

-- | Find the offset in number of elements that is between the two pointers
--   by subtracting one address from another and dividing the result by the
--   size of an element.
minusOffPtr :: Prim e => Ptr e -> Ptr e -> Off e

-- | Same as <a>minusOffPtr</a>, but will also return the remainder in
--   bytes that is left over.
minusOffRemPtr :: Prim e => Ptr e -> Ptr e -> (Off e, Off Word8)

-- | Find the offset in bytes that is between the two pointers by
--   subtracting one address from another.
minusByteOffPtr :: Ptr e -> Ptr e -> Off Word8
readPtr :: (MonadPrim s m, Prim e) => Ptr e -> m e
readOffPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> m e
readByteOffPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off Word8 -> m e
writePtr :: (MonadPrim s m, Prim e) => Ptr e -> e -> m ()
writeOffPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> e -> m ()
writeByteOffPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off Word8 -> e -> m ()
setOffPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> Count e -> e -> m ()
copyPtrToPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> Ptr e -> Off e -> Count e -> m ()
copyByteOffPtrToPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
movePtrToPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> Ptr e -> Off e -> Count e -> m ()
moveByteOffPtrToPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()

-- | Compare memory between two pointers. Offsets and count is in number of
--   elements, instead of byte count. Use <a>compareByteOffPtrToPtr</a>
--   when offset in bytes is required.
comparePtrToPtr :: Prim e => Ptr e -> Off e -> Ptr e -> Off e -> Count e -> Ordering

-- | Same as <a>comparePtrToPtr</a>, except offset is in bytes instead of
--   number of elements.
compareByteOffPtrToPtr :: Prim e => Ptr e -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> Ordering

-- | Same as <a>freeHaskellFunPtr</a>
freeHaskellFunPtr :: MonadPrim s m => FunPtr a -> m ()

-- | A value of type <tt><a>Ptr</a> a</tt> represents a pointer to an
--   object, or an array of objects, which may be marshalled to or from
--   Haskell values of type <tt>a</tt>.
--   
--   The type <tt>a</tt> will often be an instance of class <a>Storable</a>
--   which provides the marshalling operations. However this is not
--   essential, and you can provide your own operations to access the
--   pointer. For example you might write small foreign functions to get or
--   set the fields of a C <tt>struct</tt>.
data Ptr a

-- | A value of type <tt><a>FunPtr</a> a</tt> is a pointer to a function
--   callable from foreign code. The type <tt>a</tt> will normally be a
--   <i>foreign type</i>, a function type with zero or more arguments where
--   
--   <ul>
--   <li>the argument types are <i>marshallable foreign types</i>, i.e.
--   <a>Char</a>, <a>Int</a>, <a>Double</a>, <a>Float</a>, <a>Bool</a>,
--   <a>Int8</a>, <a>Int16</a>, <a>Int32</a>, <a>Int64</a>, <a>Word8</a>,
--   <a>Word16</a>, <a>Word32</a>, <a>Word64</a>, <tt><a>Ptr</a> a</tt>,
--   <tt><a>FunPtr</a> a</tt>, <tt><a>StablePtr</a> a</tt> or a renaming of
--   any of these using <tt>newtype</tt>.</li>
--   <li>the return type is either a marshallable foreign type or has the
--   form <tt><a>IO</a> t</tt> where <tt>t</tt> is a marshallable foreign
--   type or <tt>()</tt>.</li>
--   </ul>
--   
--   A value of type <tt><a>FunPtr</a> a</tt> may be a pointer to a foreign
--   function, either returned by another foreign function or imported with
--   a a static address import like
--   
--   <pre>
--   foreign import ccall "stdlib.h &amp;free"
--     p_free :: FunPtr (Ptr a -&gt; IO ())
--   </pre>
--   
--   or a pointer to a Haskell function created using a <i>wrapper</i> stub
--   declared to produce a <a>FunPtr</a> of the correct type. For example:
--   
--   <pre>
--   type Compare = Int -&gt; Int -&gt; Bool
--   foreign import ccall "wrapper"
--     mkCompare :: Compare -&gt; IO (FunPtr Compare)
--   </pre>
--   
--   Calls to wrapper stubs like <tt>mkCompare</tt> allocate storage, which
--   should be released with <a>freeHaskellFunPtr</a> when no longer
--   required.
--   
--   To convert <a>FunPtr</a> values to corresponding Haskell functions,
--   one can define a <i>dynamic</i> stub for the specific foreign type,
--   e.g.
--   
--   <pre>
--   type IntFunction = CInt -&gt; IO ()
--   foreign import ccall "dynamic"
--     mkFun :: FunPtr IntFunction -&gt; IntFunction
--   </pre>
data FunPtr a

-- | Casts a <a>Ptr</a> to a <a>FunPtr</a>.
--   
--   <i>Note:</i> this is valid only on architectures where data and
--   function pointers range over the same set of addresses, and should
--   only be used for bindings to external libraries whose interface
--   already relies on this assumption.
castPtrToFunPtr :: Ptr a -> FunPtr b

-- | Casts a <a>FunPtr</a> to a <a>Ptr</a>.
--   
--   <i>Note:</i> this is valid only on architectures where data and
--   function pointers range over the same set of addresses, and should
--   only be used for bindings to external libraries whose interface
--   already relies on this assumption.
castFunPtrToPtr :: FunPtr a -> Ptr b

-- | Casts a <a>FunPtr</a> to a <a>FunPtr</a> of a different type.
castFunPtr :: FunPtr a -> FunPtr b

-- | The constant <a>nullFunPtr</a> contains a distinguished value of
--   <a>FunPtr</a> that is not associated with a valid memory location.
nullFunPtr :: FunPtr a

-- | Computes the offset required to get from the second to the first
--   argument. We have
--   
--   <pre>
--   p2 == p1 `plusPtr` (p2 `minusPtr` p1)
--   </pre>
minusPtr :: Ptr a -> Ptr b -> Int

-- | Given an arbitrary address and an alignment constraint,
--   <a>alignPtr</a> yields the next higher address that fulfills the
--   alignment constraint. An alignment constraint <tt>x</tt> is fulfilled
--   by any address divisible by <tt>x</tt>. This operation is idempotent.
alignPtr :: Ptr a -> Int -> Ptr a

-- | Advances the given address by the given offset in bytes.
plusPtr :: Ptr a -> Int -> Ptr b

-- | The <a>castPtr</a> function casts a pointer from one type to another.
castPtr :: Ptr a -> Ptr b

-- | The constant <a>nullPtr</a> contains a distinguished value of
--   <a>Ptr</a> that is not associated with a valid memory location.
nullPtr :: Ptr a

-- | An unsigned integral type that can be losslessly converted to and from
--   <tt>Ptr</tt>. This type is also compatible with the C99 type
--   <tt>uintptr_t</tt>, and can be marshalled to and from that type
--   safely.
newtype WordPtr
WordPtr :: Word -> WordPtr

-- | casts a <tt>Ptr</tt> to a <tt>WordPtr</tt>
ptrToWordPtr :: Ptr a -> WordPtr

-- | casts a <tt>WordPtr</tt> to a <tt>Ptr</tt>
wordPtrToPtr :: WordPtr -> Ptr a

-- | A signed integral type that can be losslessly converted to and from
--   <tt>Ptr</tt>. This type is also compatible with the C99 type
--   <tt>intptr_t</tt>, and can be marshalled to and from that type safely.
newtype IntPtr
IntPtr :: Int -> IntPtr

-- | casts a <tt>Ptr</tt> to an <tt>IntPtr</tt>
ptrToIntPtr :: Ptr a -> IntPtr

-- | casts an <tt>IntPtr</tt> to a <tt>Ptr</tt>
intPtrToPtr :: IntPtr -> Ptr a

-- | Perform atomic modification of an element in the <a>Ptr</a> at the
--   supplied index. Returns the artifact of computation <tt><b>b</b></tt>.
--   Offset is in number of elements, rather than bytes. Implies a full
--   memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
casOffPtr :: (MonadPrim s m, Atomic e) => Ptr e -> Off e -> e -> e -> m e

-- | Perform atomic modification of an element in the <a>Ptr</a> at the
--   supplied index. Returns the artifact of computation <tt><b>b</b></tt>.
--   Offset is in number of elements, rather than bytes. Implies a full
--   memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicModifyOffPtr :: (MonadPrim s m, Atomic e) => Ptr e -> Off e -> (e -> (e, b)) -> m b

-- | Perform atomic modification of an element in the <a>Ptr</a> at the
--   supplied index. Offset is in number of elements, rather than bytes.
--   Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicModifyOffPtr_ :: (MonadPrim s m, Atomic e) => Ptr e -> Off e -> (e -> e) -> m ()

-- | Perform atomic modification of an element in the <a>Ptr</a> at the
--   supplied index. Returns the previous value. Offset is in number of
--   elements, rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicModifyFetchOldOffPtr :: (MonadPrim s m, Atomic e) => Ptr e -> Off e -> (e -> e) -> m e

-- | Perform atomic modification of an element in the <a>Ptr</a> at the
--   supplied index. Offset is in number of elements, rather than bytes.
--   Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicModifyFetchNewOffPtr :: (MonadPrim s m, Atomic e) => Ptr e -> Off e -> (e -> e) -> m e

-- | Add a numeric value to an element of a <a>Ptr</a>, corresponds to
--   <tt>(<a>+</a>)</tt> done atomically. Returns the previous value.
--   Offset is in number of elements, rather than bytes. Implies a full
--   memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicAddFetchOldOffPtr :: (MonadPrim s m, AtomicCount e) => Ptr e -> Off e -> e -> m e

-- | Add a numeric value to an element of a <a>Ptr</a>, corresponds to
--   <tt>(<a>+</a>)</tt> done atomically. Returns the new value. Offset is
--   in number of elements, rather than bytes. Implies a full memory
--   barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicAddFetchNewOffPtr :: (MonadPrim s m, AtomicCount e) => Ptr e -> Off e -> e -> m e

-- | Subtract a numeric value from an element of a <a>Ptr</a>, corresponds
--   to <tt>(<a>-</a>)</tt> done atomically. Returns the previous value.
--   Offset is in number of elements, rather than bytes. Implies a full
--   memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicSubFetchOldOffPtr :: (MonadPrim s m, AtomicCount e) => Ptr e -> Off e -> e -> m e

-- | Subtract a numeric value from an element of a <a>Ptr</a>, corresponds
--   to <tt>(<a>-</a>)</tt> done atomically. Returns the new value. Offset
--   is in number of elements, rather than bytes. Implies a full memory
--   barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicSubFetchNewOffPtr :: (MonadPrim s m, AtomicCount e) => Ptr e -> Off e -> e -> m e

-- | Binary conjunction (AND) of an element of a <a>Ptr</a> with the
--   supplied value, corresponds to <tt>(<a>.&amp;.</a>)</tt> done
--   atomically. Returns the previous value. Offset is in number of
--   elements, rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicAndFetchOldOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

-- | Binary conjunction (AND) of an element of a <a>Ptr</a> with the
--   supplied value, corresponds to <tt>(<a>.&amp;.</a>)</tt> done
--   atomically. Returns the new value. Offset is in number of elements,
--   rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicAndFetchNewOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

-- | Negation of binary conjunction (NAND) of an element of a <a>Ptr</a>
--   with the supplied value, corresponds to <tt>\x y -&gt;
--   <a>complement</a> (x <a>.&amp;.</a> y)</tt> done atomically. Returns
--   the previous value. Offset is in number of elements, rather than
--   bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicNandFetchOldOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

-- | Negation of binary conjunction (NAND) of an element of a <a>Ptr</a>
--   with the supplied value, corresponds to <tt>\x y -&gt;
--   <a>complement</a> (x <a>.&amp;.</a> y)</tt> done atomically. Returns
--   the new value. Offset is in number of elements, rather than bytes.
--   Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicNandFetchNewOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

-- | Binary disjunction (OR) of an element of a <a>Ptr</a> with the
--   supplied value, corresponds to <tt>(<a>.|.</a>)</tt> done atomically.
--   Returns the previous value. Offset is in number of elements, rather
--   than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicOrFetchOldOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

-- | Binary disjunction (OR) of an element of a <a>Ptr</a> with the
--   supplied value, corresponds to <tt>(<a>.|.</a>)</tt> done atomically.
--   Returns the new value. Offset is in number of elements, rather than
--   bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicOrFetchNewOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

-- | Binary exclusive disjunction (XOR) of an element of a <a>Ptr</a> with
--   the supplied value, corresponds to <tt><a>xor</a></tt> done
--   atomically. Returns the previous value. Offset is in number of
--   elements, rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicXorFetchOldOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

-- | Binary exclusive disjunction (XOR) of an element of a <a>Ptr</a> with
--   the supplied value, corresponds to <tt><a>xor</a></tt> done
--   atomically. Returns the new value. Offset is in number of elements,
--   rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicXorFetchNewOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

-- | Binary negation (NOT) of an element of a <a>Ptr</a>, corresponds to
--   <tt>(<a>complement</a>)</tt> done atomically. Returns the previous
--   value. Offset is in number of elements, rather than bytes. Implies a
--   full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicNotFetchOldOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> m e

-- | Binary negation (NOT) of an element of a <a>Ptr</a>, corresponds to
--   <tt>(<a>complement</a>)</tt> done atomically. Returns the new value.
--   Offset is in number of elements, rather than bytes. Implies a full
--   memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicNotFetchNewOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> m e
prefetchPtr0 :: MonadPrim s m => Ptr e -> m ()
prefetchPtr1 :: MonadPrim s m => Ptr a -> m ()
prefetchPtr2 :: MonadPrim s m => Ptr e -> m ()
prefetchPtr3 :: MonadPrim s m => Ptr e -> m ()
prefetchOffPtr0 :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> m ()
prefetchOffPtr1 :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> m ()
prefetchOffPtr2 :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> m ()
prefetchOffPtr3 :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> m ()


module Foreign.Prim.StablePtr

-- | A <i>stable pointer</i> is a reference to a Haskell expression that is
--   guaranteed not to be affected by garbage collection, i.e., it will
--   neither be deallocated nor will the value of the stable pointer itself
--   change during garbage collection (ordinary references may be relocated
--   during garbage collection). Consequently, stable pointers can be
--   passed to foreign code, which can treat it as an opaque reference to a
--   Haskell value.
--   
--   A value of type <tt>StablePtr a</tt> is a stable pointer to a Haskell
--   expression of type <tt>a</tt>.
data StablePtr a
StablePtr :: StablePtr# a -> StablePtr a

-- | Same as <a>newStablePtr</a>, but generalized to <a>MonadPrim</a>
newStablePtr :: MonadPrim RW m => a -> m (StablePtr a)

-- | Same as <a>deRefStablePtr</a>, but generalized to <a>MonadPrim</a>
deRefStablePtr :: MonadPrim RW m => StablePtr a -> m a

-- | Same as <a>freeStablePtr</a>, but generalized to <a>MonadPrim</a>
freeStablePtr :: MonadPrim RW m => StablePtr a -> m ()

-- | Coerce a stable pointer to an address. No guarantees are made about
--   the resulting value, except that the original stable pointer can be
--   recovered by <a>castPtrToStablePtr</a>. In particular, the address may
--   not refer to an accessible memory location and any attempt to pass it
--   to the member functions of the class <a>Storable</a> leads to
--   undefined behaviour.
castStablePtrToPtr :: StablePtr a -> Ptr ()

-- | The inverse of <a>castStablePtrToPtr</a>, i.e., we have the identity
--   
--   <pre>
--   sp == castPtrToStablePtr (castStablePtrToPtr sp)
--   </pre>
--   
--   for any stable pointer <tt>sp</tt> on which <a>freeStablePtr</a> has
--   not been executed yet. Moreover, <a>castPtrToStablePtr</a> may only be
--   applied to pointers that have been produced by
--   <a>castStablePtrToPtr</a>.
castPtrToStablePtr :: Ptr () -> StablePtr a
instance Control.DeepSeq.NFData (GHC.Stable.StablePtr a)
instance GHC.Show.Show (GHC.Stable.StablePtr a)


module Foreign.Prim.WeakPtr

-- | A weak pointer object with a key and a value. The value has type
--   <tt>v</tt>.
--   
--   A weak pointer expresses a relationship between two objects, the
--   <i>key</i> and the <i>value</i>: if the key is considered to be alive
--   by the garbage collector, then the value is also alive. A reference
--   from the value to the key does <i>not</i> keep the key alive.
--   
--   A weak pointer may also have a finalizer of type <tt>IO ()</tt>; if it
--   does, then the finalizer will be run at most once, at a time after the
--   key has become unreachable by the program ("dead"). The storage
--   manager attempts to run the finalizer(s) for an object soon after the
--   object dies, but promptness is not guaranteed.
--   
--   It is not guaranteed that a finalizer will eventually run, and no
--   attempt is made to run outstanding finalizers when the program exits.
--   Therefore finalizers should not be relied on to clean up resources -
--   other methods (eg. exception handlers) should be employed, possibly in
--   addition to finalizers.
--   
--   References from the finalizer to the key are treated in the same way
--   as references from the value to the key: they do not keep the key
--   alive. A finalizer may therefore ressurrect the key, perhaps by
--   storing it in the same data structure.
--   
--   The finalizer, and the relationship between the key and the value,
--   exist regardless of whether the program keeps a reference to the
--   <a>Weak</a> object or not.
--   
--   There may be multiple weak pointers with the same key. In this case,
--   the finalizers for each of these weak pointers will all be run in some
--   arbitrary order, or perhaps concurrently, when the key dies. If the
--   programmer specifies a finalizer that assumes it has the only
--   reference to an object (for example, a file that it wishes to close),
--   then the programmer must ensure that there is only one such finalizer.
--   
--   If there are no other threads to run, the runtime system will check
--   for runnable finalizers before declaring the system to be deadlocked.
--   
--   WARNING: weak pointers to ordinary non-primitive Haskell types are
--   particularly fragile, because the compiler is free to optimise away or
--   duplicate the underlying data structure. Therefore attempting to place
--   a finalizer on an ordinary Haskell type may well result in the
--   finalizer running earlier than you expected. This is not a problem for
--   caches and memo tables where early finalization is benign.
--   
--   Finalizers <i>can</i> be used reliably for types that are created
--   explicitly and have identity, such as <tt>IORef</tt> and
--   <tt>MVar</tt>. However, to place a finalizer on one of these types,
--   you should use the specific operation provided for that type, e.g.
--   <tt>mkWeakIORef</tt> and <tt>addMVarFinalizer</tt> respectively (the
--   non-uniformity is accidental). These operations attach the finalizer
--   to the primitive object inside the box (e.g. <tt>MutVar#</tt> in the
--   case of <tt>IORef</tt>), because attaching the finalizer to the box
--   itself fails when the outer box is optimised away by the compiler.
data Weak v
Weak :: Weak# v -> Weak v

-- | Same as <a>mkWeak</a>, except it requires a finalizer to be supplied.
--   For a version without finalizers use <a>mkWeakNoFinalizer</a>
mkWeak :: MonadUnliftPrim RW m => a -> v -> m b -> m (Weak v)

-- | Similar to <a>mkWeak</a>, except it does not require a finalizer.
mkWeakNoFinalizer :: MonadPrim RW m => a -> v -> m (Weak v)

-- | Same as <a>mkWeakPtr</a>, except it requires a finalizer to be
--   supplied. For a version without finalizers use
--   <a>mkWeakPtrNoFinalizer</a>
mkWeakPtr :: MonadUnliftPrim RW m => k -> m b -> m (Weak k)

-- | Similar to <a>mkWeakPtr</a>, except it does not require a finalizer.
mkWeakPtrNoFinalizer :: MonadPrim RW m => k -> m (Weak k)

-- | Same as <a>addFinalizer</a>.
addFinalizer :: MonadUnliftPrim RW m => k -> m b -> m ()

-- | Add a foreign function finalizer with a single argument
addCFinalizer :: MonadPrim RW m => FunPtr (Ptr a -> IO ()) -> Ptr a -> Weak v -> m Bool

-- | Add a foreign function finalizer with two arguments
addCFinalizerEnv :: MonadPrim RW m => FunPtr (Ptr env -> Ptr a -> IO ()) -> Ptr env -> Ptr a -> Weak v -> m Bool

-- | Similar to <a>deRefWeak</a>
deRefWeak :: MonadPrim RW m => Weak v -> m (Maybe v)

-- | Similar to <a>finalize</a>
finalizeWeak :: MonadPrim RW m => Weak v -> m ()


module Data.Prim.Ref

-- | Mutable variable that can hold any value. This is just like
--   <a>STRef</a>, but with type arguments flipped and is generalized to
--   work in <a>MonadPrim</a>. It only stores a reference to the value
--   which means it works on boxed values. If the type can be unboxed with
--   <a>Prim</a> class, consider using <a><tt>PVar</tt></a> package
--   instead.
data Ref a s
Ref :: MutVar# s a -> Ref a s

-- | Compatibility synonym
type IORef a = Ref a RW

-- | Compatibility synonym
type STRef s a = Ref a s

-- | Create a new mutable variable. Initial value will be forced to WHNF
--   (weak head normal form).
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; import Debug.Trace
--   
--   &gt;&gt;&gt; import Data.Prim.Ref
--   
--   &gt;&gt;&gt; ref &lt;- newRef (trace "Initial value is evaluated" (217 :: Int))
--   Initial value is evaluated
--   
--   &gt;&gt;&gt; modifyFetchOldRef ref succ
--   217
--   
--   &gt;&gt;&gt; readRef ref
--   218
--   </pre>
newRef :: MonadPrim s m => a -> m (Ref a s)

-- | Create a new mutable variable. Same as <a>newRef</a>, but ensures that
--   value is evaluated to normal form.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; import Debug.Trace
--   
--   &gt;&gt;&gt; import Data.Prim.Ref
--   
--   &gt;&gt;&gt; ref &lt;- newDeepRef (Just (trace "Initial value is evaluated" (217 :: Int)))
--   Initial value is evaluated
--   
--   &gt;&gt;&gt; readRef ref
--   Just 217
--   </pre>
newDeepRef :: (NFData a, MonadPrim s m) => a -> m (Ref a s)

-- | Check whether supplied <a>Ref</a>s refer to the exact same one or not.
isSameRef :: Ref a s -> Ref a s -> Bool

-- | Read contents of the mutable variable
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Prim.Ref
--   
--   &gt;&gt;&gt; ref &lt;- newRef "Hello World!"
--   
--   &gt;&gt;&gt; readRef ref
--   "Hello World!"
--   </pre>
readRef :: MonadPrim s m => Ref a s -> m a

-- | Swap a value of a mutable variable with a new one, while retrieving
--   the old one. New value is evaluated prior to it being written to the
--   variable.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ref &lt;- newRef (Left "Initial" :: Either String String)
--   
--   &gt;&gt;&gt; swapRef ref (Right "Last")
--   Left "Initial"
--   
--   &gt;&gt;&gt; readRef ref
--   Right "Last"
--   </pre>
swapRef :: MonadPrim s m => Ref a s -> a -> m a

-- | Swap a value of a mutable variable with a new one, while retrieving
--   the old one. New value is evaluated to <b>normal</b> form prior to it
--   being written to the variable.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ref &lt;- newRef (Just "Initial")
--   
--   &gt;&gt;&gt; swapDeepRef ref (Just (errorWithoutStackTrace "foo"))
--   *** Exception: foo
--   
--   &gt;&gt;&gt; readRef ref
--   Just "Initial"
--   </pre>
swapDeepRef :: (NFData a, MonadPrim s m) => Ref a s -> a -> m a

-- | Write a value into a mutable variable strictly. If evaluating a value
--   results in exception, original value in the mutable variable will not
--   be affected. Another great benfit of this over <a>writeLazyRef</a> is
--   that it helps avoiding memory leaks.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ref &lt;- newRef "Original value"
--   
--   &gt;&gt;&gt; import Control.Prim.Exception
--   
--   &gt;&gt;&gt; _ &lt;- try $ writeRef ref undefined :: IO (Either SomeException ())
--   
--   &gt;&gt;&gt; readRef ref
--   "Original value"
--   
--   &gt;&gt;&gt; writeRef ref "New total value"
--   
--   &gt;&gt;&gt; readRef ref
--   "New total value"
--   </pre>
writeRef :: MonadPrim s m => Ref a s -> a -> m ()

-- | Same as <a>writeRef</a>, but will evaluate the argument to Normal Form
--   prior to writing it to the <a>Ref</a>
writeDeepRef :: (NFData a, MonadPrim s m) => Ref a s -> a -> m ()

-- | Apply a pure function to the contents of a mutable variable strictly.
--   Returns the artifact produced by the modifying function. Artifact is
--   not forced, therfore it cannot affect the outcome of modification.
--   This function is a faster alternative to <a>atomicModifyRef</a>,
--   except without any guarantees of atomicity and ordering of mutable
--   operations during concurrent modification of the same <a>Ref</a>. For
--   lazy version see <a>modifyLazyRef</a> and for strict evaluation to
--   normal form see <a>modifyDeepRef</a>.
modifyRef :: MonadPrim s m => Ref a s -> (a -> (a, b)) -> m b

-- | Same as <a>modifyRef</a>, except it will evaluate result of
--   computation to normal form.
modifyDeepRef :: (NFData a, MonadPrim s m) => Ref a s -> (a -> (a, b)) -> m b

-- | Apply a pure function to the contents of a mutable variable strictly.
modifyRef_ :: MonadPrim s m => Ref a s -> (a -> a) -> m ()

-- | Apply a pure function to the contents of a mutable variable strictly.
--   Returns the new value.
modifyFetchNewRef :: MonadPrim s m => Ref a s -> (a -> a) -> m a

-- | Apply a pure function to the contents of a mutable variable strictly.
--   Returns the old value.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ref1 &lt;- newRef (10 :: Int)
--   
--   &gt;&gt;&gt; ref2 &lt;- newRef (201 :: Int)
--   
--   &gt;&gt;&gt; modifyRefM_ ref1 (\x -&gt; modifyFetchOldRef ref2 (* x))
--   
--   &gt;&gt;&gt; readRef ref1
--   201
--   
--   &gt;&gt;&gt; readRef ref2
--   2010
--   </pre>
modifyFetchOldRef :: MonadPrim s m => Ref a s -> (a -> a) -> m a

-- | Modify value of a mutable variable with a monadic action. It is not
--   strict in a return value of type <tt>b</tt>, but the ne value written
--   into the mutable variable is evaluated to WHNF.
--   
--   <h4><b>Examples</b></h4>
modifyRefM :: MonadPrim s m => Ref a s -> (a -> m (a, b)) -> m b

-- | Same as <a>modifyRefM</a>, except evaluates new value to normal form
--   prior ot it being written to the mutable ref.
modifyDeepRefM :: (NFData a, MonadPrim s m) => Ref a s -> (a -> m (a, b)) -> m b

-- | Modify value of a mutable variable with a monadic action. Result is
--   written strictly.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ref &lt;- newRef (Just "Some value")
--   
--   &gt;&gt;&gt; modifyRefM_ ref $ \ mv -&gt; Nothing &lt;$ mapM_ putStrLn mv
--   Some value
--   
--   &gt;&gt;&gt; readRef ref
--   Nothing
--   </pre>
modifyRefM_ :: MonadPrim s m => Ref a s -> (a -> m a) -> m ()

-- | Apply a monadic action to the contents of a mutable variable strictly.
--   Returns the new value.
modifyFetchNewRefM :: MonadPrim s m => Ref a s -> (a -> m a) -> m a

-- | Apply a monadic action to the contents of a mutable variable strictly.
--   Returns the old value.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; refName &lt;- newRef "My name is: "
--   
--   &gt;&gt;&gt; refMyName &lt;- newRef "Alexey"
--   
--   &gt;&gt;&gt; myName &lt;- modifyFetchOldRefM refMyName $ \ name -&gt; "Leo" &lt;$ modifyRef_ refName (++ name)
--   
--   &gt;&gt;&gt; readRef refName &gt;&gt;= putStrLn
--   My name is: Alexey
--   
--   &gt;&gt;&gt; putStrLn myName
--   Alexey
--   
--   &gt;&gt;&gt; readRef refMyName &gt;&gt;= putStrLn
--   Leo
--   </pre>
modifyFetchOldRefM :: MonadPrim s m => Ref a s -> (a -> m a) -> m a

-- | This will behave exactly the same as <a>readRef</a> when the
--   <a>Ref</a> is accessed within a single thread only. However, despite
--   being slower, it can help with with restricting order of operations in
--   cases when multiple threads perform modifications to the <a>Ref</a>
--   because it implies a memory barrier.
atomicReadRef :: MonadPrim s m => Ref e s -> m e

-- | Same as <a>atomicWriteRef</a>, but also returns the old value.
atomicSwapRef :: MonadPrim s m => Ref e s -> e -> m e

-- | Evaluate a value and write it atomically into a <a>Ref</a>. This is
--   different from <a>writeRef</a> because <a>a memory barrier</a> will be
--   issued. Use this instead of <a>writeRef</a> in order to guarantee the
--   ordering of operations in a concurrent environment.
atomicWriteRef :: MonadPrim s m => Ref e s -> e -> m ()

-- | Apply a function to the value stored in a mutable <a>Ref</a>
--   atomically. Function is applied strictly with respect to the newly
--   returned value, which matches the semantics of
--   <tt>atomicModifyIORef</tt>`, however the difference is that the
--   artifact returned by the action is not evaluated.
--   
--   <h4><b>Example</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; 
--   </pre>
atomicModifyRef :: MonadPrim s m => Ref a s -> (a -> (a, b)) -> m b
atomicModifyRef_ :: MonadPrim s m => Ref a s -> (a -> a) -> m ()

-- | Appy a function to the value in mutable <a>Ref</a> atomically
atomicModifyFetchRef :: MonadPrim s m => Ref a s -> (a -> (a, b)) -> m (a, a, b)
atomicModifyFetchNewRef :: MonadPrim s m => Ref a s -> (a -> a) -> m a
atomicModifyFetchOldRef :: MonadPrim s m => Ref a s -> (a -> a) -> m a
atomicModifyFetchBothRef :: MonadPrim s m => Ref a s -> (a -> a) -> m (a, a)
casRef :: MonadPrim s m => Ref a s -> a -> a -> m (Bool, a)
atomicModifyRef2 :: MonadPrim s m => Ref a s -> (a -> (a, b)) -> m b
atomicModifyRef2_ :: MonadPrim s m => Ref a s -> (a -> a) -> m ()
atomicModifyFetchNewRef2 :: MonadPrim s m => Ref a s -> (a -> a) -> m a
atomicModifyFetchOldRef2 :: MonadPrim s m => Ref a s -> (a -> a) -> m a
atomicModifyFetchBothRef2 :: MonadPrim s m => Ref a s -> (a -> a) -> m (a, a)
atomicModifyFetchRef2 :: MonadPrim s m => Ref a s -> (a -> (a, b)) -> m (a, a, b)

-- | Create a new mutable variable. Initial value stays unevaluated.
--   
--   <h4><b>Examples</b></h4>
--   
--   In below example you will see that initial value is never evaluated.
--   
--   <pre>
--   &gt;&gt;&gt; import Debug.Trace
--   
--   &gt;&gt;&gt; import Data.Prim.Ref
--   
--   &gt;&gt;&gt; ref &lt;- newLazyRef (trace "Initial value is evaluated" (undefined :: Int))
--   
--   &gt;&gt;&gt; writeRef ref 1024
--   
--   &gt;&gt;&gt; modifyFetchNewRef ref succ
--   1025
--   </pre>
newLazyRef :: MonadPrim s m => a -> m (Ref a s)

-- | Write a value into a mutable variable lazily.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ref &lt;- newRef "Original value"
--   
--   &gt;&gt;&gt; import Debug.Trace
--   
--   &gt;&gt;&gt; writeLazyRef ref (trace "'New string' is evaluated" "New string")
--   
--   &gt;&gt;&gt; x &lt;- readRef ref
--   
--   &gt;&gt;&gt; writeRef ref (trace "'Totally new string' is evaluated" "Totally new string")
--   'Totally new string' is evaluated
--   
--   &gt;&gt;&gt; putStrLn x
--   'New string' is evaluated
--   New string
--   </pre>
writeLazyRef :: MonadPrim s m => Ref a s -> a -> m ()

-- | Swap a value of a mutable variable with a new one lazily, while
--   retrieving the old one. New value is <b>not</b> evaluated prior to it
--   being written to the variable.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; ref &lt;- newRef "Initial"
--   
--   &gt;&gt;&gt; swapLazyRef ref undefined
--   "Initial"
--   
--   &gt;&gt;&gt; _ &lt;- swapLazyRef ref "Different"
--   
--   &gt;&gt;&gt; readRef ref
--   "Different"
--   </pre>
swapLazyRef :: MonadPrim s m => Ref a s -> a -> m a

-- | Apply a pure function to the contents of a mutable variable lazily.
--   Returns the artifact produced by the modifying function.
modifyLazyRef :: MonadPrim s m => Ref a s -> (a -> (a, b)) -> m b

-- | Same as <a>modifyRefM</a>, but do not evaluate the new value written
--   into the <a>Ref</a>.
modifyLazyRefM :: MonadPrim s m => Ref a s -> (a -> m (a, b)) -> m b
atomicWriteLazyRef :: MonadPrim s m => Ref b s -> b -> m ()
atomicModifyLazyRef :: MonadPrim s m => Ref a s -> (a -> (a, b)) -> m b
atomicModifyFetchNewLazyRef :: MonadPrim s m => Ref a s -> (a -> a) -> m a
atomicModifyFetchOldLazyRef :: MonadPrim s m => Ref a s -> (a -> a) -> m a
atomicModifyFetchBothLazyRef :: MonadPrim s m => Ref a s -> (a -> a) -> m (a, a)
atomicModifyFetchLazyRef :: MonadPrim s m => Ref a s -> (a -> (a, b)) -> m (a, a, b)

-- | Convert <a>Ref</a> to <a>STRef</a>
toSTRef :: Ref a s -> STRef s a

-- | Convert <a>STRef</a> to <a>Ref</a>
fromSTRef :: STRef s a -> Ref a s

-- | Convert <a>Ref</a> to <a>IORef</a>
toIORef :: Ref a RW -> IORef a

-- | Convert <a>IORef</a> to <a>Ref</a>
fromIORef :: IORef a -> Ref a RW

-- | Create a <a>Weak</a> pointer associated with the supplied <a>Ref</a>.
--   
--   Same as <a>mkWeakRef</a> from <tt>base</tt>, but works in any
--   <a>MonadPrim</a> with <a>RealWorld</a> state token.
mkWeakRef :: forall a b m. MonadUnliftPrim RW m => Ref a RW -> m b -> m (Weak (Ref a RW))
instance GHC.Classes.Eq (Data.Prim.Ref.Ref a s)