{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE UndecidableInstances #-}
-- |
-- Module      : Data.Prim.Atom
-- Copyright   : (c) Alexey Kuleshevich 2020
-- License     : BSD3
-- Maintainer  : Alexey Kuleshevich <alexey@kuleshevi.ch>
-- Stability   : experimental
-- Portability : non-portable
--
module Data.Prim.Atom
  ( Atom(..)
  -- * SpinLocks
  , acquireLockByteOffMutableByteArray
  , releaseLockByteOffMutableByteArray
  , acquireLockByteOffAddr
  , releaseLockByteOffAddr
  , withLockMutableByteArray
  , withLockOffAddr
  -- * Helpers and testing
  --
  -- Functions below are used for implementing `Atom` instances and are useful for
  -- testing other types as well as defining potential cusom instances
  -- ** Count
  , atomicAddFetchOldMutableByteArrayNum#
  , atomicAddFetchNewMutableByteArrayNum#
  , atomicSubFetchOldMutableByteArrayNum#
  , atomicSubFetchNewMutableByteArrayNum#
  , atomicAddFetchOldOffAddrNum#
  , atomicAddFetchNewOffAddrNum#
  , atomicSubFetchOldOffAddrNum#
  , atomicSubFetchNewOffAddrNum#
  -- ** Bits
  , atomicAndFetchOldMutableByteArrayBits#
  , atomicAndFetchNewMutableByteArrayBits#
  , atomicNandFetchOldMutableByteArrayBits#
  , atomicNandFetchNewMutableByteArrayBits#
  , atomicOrFetchOldMutableByteArrayBits#
  , atomicOrFetchNewMutableByteArrayBits#
  , atomicXorFetchOldMutableByteArrayBits#
  , atomicXorFetchNewMutableByteArrayBits#
  , atomicAndFetchOldOffAddrBits#
  , atomicAndFetchNewOffAddrBits#
  , atomicNandFetchOldOffAddrBits#
  , atomicNandFetchNewOffAddrBits#
  , atomicOrFetchOldOffAddrBits#
  , atomicOrFetchNewOffAddrBits#
  , atomicXorFetchOldOffAddrBits#
  , atomicXorFetchNewOffAddrBits#
  ) where

import Control.DeepSeq
import Control.Prim.Concurrent
import Control.Prim.Exception
import Control.Prim.Monad.Unsafe
import Data.Bits
import Data.Prim.Atomic
import Data.Prim.Class
import Foreign.Prim hiding (Any)
import GHC.TypeLits

newtype Atom a =
  Atom
    { Atom a -> a
unAtom :: a
    }
  deriving ( Int -> Atom a -> ShowS
[Atom a] -> ShowS
Atom a -> String
(Int -> Atom a -> ShowS)
-> (Atom a -> String) -> ([Atom a] -> ShowS) -> Show (Atom a)
forall a. Show a => Int -> Atom a -> ShowS
forall a. Show a => [Atom a] -> ShowS
forall a. Show a => Atom a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Atom a] -> ShowS
$cshowList :: forall a. Show a => [Atom a] -> ShowS
show :: Atom a -> String
$cshow :: forall a. Show a => Atom a -> String
showsPrec :: Int -> Atom a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Atom a -> ShowS
Show
           , Atom a -> Atom a -> Bool
(Atom a -> Atom a -> Bool)
-> (Atom a -> Atom a -> Bool) -> Eq (Atom a)
forall a. Eq a => Atom a -> Atom a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Atom a -> Atom a -> Bool
$c/= :: forall a. Eq a => Atom a -> Atom a -> Bool
== :: Atom a -> Atom a -> Bool
$c== :: forall a. Eq a => Atom a -> Atom a -> Bool
Eq
           , Eq (Atom a)
Eq (Atom a)
-> (Atom a -> Atom a -> Ordering)
-> (Atom a -> Atom a -> Bool)
-> (Atom a -> Atom a -> Bool)
-> (Atom a -> Atom a -> Bool)
-> (Atom a -> Atom a -> Bool)
-> (Atom a -> Atom a -> Atom a)
-> (Atom a -> Atom a -> Atom a)
-> Ord (Atom a)
Atom a -> Atom a -> Bool
Atom a -> Atom a -> Ordering
Atom a -> Atom a -> Atom a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Atom a)
forall a. Ord a => Atom a -> Atom a -> Bool
forall a. Ord a => Atom a -> Atom a -> Ordering
forall a. Ord a => Atom a -> Atom a -> Atom a
min :: Atom a -> Atom a -> Atom a
$cmin :: forall a. Ord a => Atom a -> Atom a -> Atom a
max :: Atom a -> Atom a -> Atom a
$cmax :: forall a. Ord a => Atom a -> Atom a -> Atom a
>= :: Atom a -> Atom a -> Bool
$c>= :: forall a. Ord a => Atom a -> Atom a -> Bool
> :: Atom a -> Atom a -> Bool
$c> :: forall a. Ord a => Atom a -> Atom a -> Bool
<= :: Atom a -> Atom a -> Bool
$c<= :: forall a. Ord a => Atom a -> Atom a -> Bool
< :: Atom a -> Atom a -> Bool
$c< :: forall a. Ord a => Atom a -> Atom a -> Bool
compare :: Atom a -> Atom a -> Ordering
$ccompare :: forall a. Ord a => Atom a -> Atom a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Atom a)
Ord
           , Integer -> Atom a
Atom a -> Atom a
Atom a -> Atom a -> Atom a
(Atom a -> Atom a -> Atom a)
-> (Atom a -> Atom a -> Atom a)
-> (Atom a -> Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Integer -> Atom a)
-> Num (Atom a)
forall a. Num a => Integer -> Atom a
forall a. Num a => Atom a -> Atom a
forall a. Num a => Atom a -> Atom a -> Atom a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Atom a
$cfromInteger :: forall a. Num a => Integer -> Atom a
signum :: Atom a -> Atom a
$csignum :: forall a. Num a => Atom a -> Atom a
abs :: Atom a -> Atom a
$cabs :: forall a. Num a => Atom a -> Atom a
negate :: Atom a -> Atom a
$cnegate :: forall a. Num a => Atom a -> Atom a
* :: Atom a -> Atom a -> Atom a
$c* :: forall a. Num a => Atom a -> Atom a -> Atom a
- :: Atom a -> Atom a -> Atom a
$c- :: forall a. Num a => Atom a -> Atom a -> Atom a
+ :: Atom a -> Atom a -> Atom a
$c+ :: forall a. Num a => Atom a -> Atom a -> Atom a
Num
           , Int -> Atom a
Atom a -> Int
Atom a -> [Atom a]
Atom a -> Atom a
Atom a -> Atom a -> [Atom a]
Atom a -> Atom a -> Atom a -> [Atom a]
(Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Int -> Atom a)
-> (Atom a -> Int)
-> (Atom a -> [Atom a])
-> (Atom a -> Atom a -> [Atom a])
-> (Atom a -> Atom a -> [Atom a])
-> (Atom a -> Atom a -> Atom a -> [Atom a])
-> Enum (Atom a)
forall a. Enum a => Int -> Atom a
forall a. Enum a => Atom a -> Int
forall a. Enum a => Atom a -> [Atom a]
forall a. Enum a => Atom a -> Atom a
forall a. Enum a => Atom a -> Atom a -> [Atom a]
forall a. Enum a => Atom a -> Atom a -> Atom a -> [Atom a]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Atom a -> Atom a -> Atom a -> [Atom a]
$cenumFromThenTo :: forall a. Enum a => Atom a -> Atom a -> Atom a -> [Atom a]
enumFromTo :: Atom a -> Atom a -> [Atom a]
$cenumFromTo :: forall a. Enum a => Atom a -> Atom a -> [Atom a]
enumFromThen :: Atom a -> Atom a -> [Atom a]
$cenumFromThen :: forall a. Enum a => Atom a -> Atom a -> [Atom a]
enumFrom :: Atom a -> [Atom a]
$cenumFrom :: forall a. Enum a => Atom a -> [Atom a]
fromEnum :: Atom a -> Int
$cfromEnum :: forall a. Enum a => Atom a -> Int
toEnum :: Int -> Atom a
$ctoEnum :: forall a. Enum a => Int -> Atom a
pred :: Atom a -> Atom a
$cpred :: forall a. Enum a => Atom a -> Atom a
succ :: Atom a -> Atom a
$csucc :: forall a. Enum a => Atom a -> Atom a
Enum
           , Enum (Atom a)
Real (Atom a)
Real (Atom a)
-> Enum (Atom a)
-> (Atom a -> Atom a -> Atom a)
-> (Atom a -> Atom a -> Atom a)
-> (Atom a -> Atom a -> Atom a)
-> (Atom a -> Atom a -> Atom a)
-> (Atom a -> Atom a -> (Atom a, Atom a))
-> (Atom a -> Atom a -> (Atom a, Atom a))
-> (Atom a -> Integer)
-> Integral (Atom a)
Atom a -> Integer
Atom a -> Atom a -> (Atom a, Atom a)
Atom a -> Atom a -> Atom a
forall a. Integral a => Enum (Atom a)
forall a. Integral a => Real (Atom a)
forall a. Integral a => Atom a -> Integer
forall a. Integral a => Atom a -> Atom a -> (Atom a, Atom a)
forall a. Integral a => Atom a -> Atom a -> Atom a
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
toInteger :: Atom a -> Integer
$ctoInteger :: forall a. Integral a => Atom a -> Integer
divMod :: Atom a -> Atom a -> (Atom a, Atom a)
$cdivMod :: forall a. Integral a => Atom a -> Atom a -> (Atom a, Atom a)
quotRem :: Atom a -> Atom a -> (Atom a, Atom a)
$cquotRem :: forall a. Integral a => Atom a -> Atom a -> (Atom a, Atom a)
mod :: Atom a -> Atom a -> Atom a
$cmod :: forall a. Integral a => Atom a -> Atom a -> Atom a
div :: Atom a -> Atom a -> Atom a
$cdiv :: forall a. Integral a => Atom a -> Atom a -> Atom a
rem :: Atom a -> Atom a -> Atom a
$crem :: forall a. Integral a => Atom a -> Atom a -> Atom a
quot :: Atom a -> Atom a -> Atom a
$cquot :: forall a. Integral a => Atom a -> Atom a -> Atom a
$cp2Integral :: forall a. Integral a => Enum (Atom a)
$cp1Integral :: forall a. Integral a => Real (Atom a)
Integral
           , Num (Atom a)
Ord (Atom a)
Num (Atom a)
-> Ord (Atom a) -> (Atom a -> Rational) -> Real (Atom a)
Atom a -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
forall a. Real a => Num (Atom a)
forall a. Real a => Ord (Atom a)
forall a. Real a => Atom a -> Rational
toRational :: Atom a -> Rational
$ctoRational :: forall a. Real a => Atom a -> Rational
$cp2Real :: forall a. Real a => Ord (Atom a)
$cp1Real :: forall a. Real a => Num (Atom a)
Real
           , Fractional (Atom a)
Real (Atom a)
Real (Atom a)
-> Fractional (Atom a)
-> (forall b. Integral b => Atom a -> (b, Atom a))
-> (forall b. Integral b => Atom a -> b)
-> (forall b. Integral b => Atom a -> b)
-> (forall b. Integral b => Atom a -> b)
-> (forall b. Integral b => Atom a -> b)
-> RealFrac (Atom a)
Atom a -> b
Atom a -> b
Atom a -> b
Atom a -> b
Atom a -> (b, Atom a)
forall b. Integral b => Atom a -> b
forall b. Integral b => Atom a -> (b, Atom a)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
forall a. RealFrac a => Fractional (Atom a)
forall a. RealFrac a => Real (Atom a)
forall a b. (RealFrac a, Integral b) => Atom a -> b
forall a b. (RealFrac a, Integral b) => Atom a -> (b, Atom a)
floor :: Atom a -> b
$cfloor :: forall a b. (RealFrac a, Integral b) => Atom a -> b
ceiling :: Atom a -> b
$cceiling :: forall a b. (RealFrac a, Integral b) => Atom a -> b
round :: Atom a -> b
$cround :: forall a b. (RealFrac a, Integral b) => Atom a -> b
truncate :: Atom a -> b
$ctruncate :: forall a b. (RealFrac a, Integral b) => Atom a -> b
properFraction :: Atom a -> (b, Atom a)
$cproperFraction :: forall a b. (RealFrac a, Integral b) => Atom a -> (b, Atom a)
$cp2RealFrac :: forall a. RealFrac a => Fractional (Atom a)
$cp1RealFrac :: forall a. RealFrac a => Real (Atom a)
RealFrac
           , Num (Atom a)
Num (Atom a)
-> (Atom a -> Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Rational -> Atom a)
-> Fractional (Atom a)
Rational -> Atom a
Atom a -> Atom a
Atom a -> Atom a -> Atom a
forall a. Fractional a => Num (Atom a)
forall a. Fractional a => Rational -> Atom a
forall a. Fractional a => Atom a -> Atom a
forall a. Fractional a => Atom a -> Atom a -> Atom a
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Atom a
$cfromRational :: forall a. Fractional a => Rational -> Atom a
recip :: Atom a -> Atom a
$crecip :: forall a. Fractional a => Atom a -> Atom a
/ :: Atom a -> Atom a -> Atom a
$c/ :: forall a. Fractional a => Atom a -> Atom a -> Atom a
$cp1Fractional :: forall a. Fractional a => Num (Atom a)
Fractional
           , Fractional (Atom a)
Atom a
Fractional (Atom a)
-> Atom a
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a -> Atom a)
-> (Atom a -> Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Atom a)
-> Floating (Atom a)
Atom a -> Atom a
Atom a -> Atom a -> Atom a
forall a. Floating a => Fractional (Atom a)
forall a. Floating a => Atom a
forall a. Floating a => Atom a -> Atom a
forall a. Floating a => Atom a -> Atom a -> Atom a
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: Atom a -> Atom a
$clog1mexp :: forall a. Floating a => Atom a -> Atom a
log1pexp :: Atom a -> Atom a
$clog1pexp :: forall a. Floating a => Atom a -> Atom a
expm1 :: Atom a -> Atom a
$cexpm1 :: forall a. Floating a => Atom a -> Atom a
log1p :: Atom a -> Atom a
$clog1p :: forall a. Floating a => Atom a -> Atom a
atanh :: Atom a -> Atom a
$catanh :: forall a. Floating a => Atom a -> Atom a
acosh :: Atom a -> Atom a
$cacosh :: forall a. Floating a => Atom a -> Atom a
asinh :: Atom a -> Atom a
$casinh :: forall a. Floating a => Atom a -> Atom a
tanh :: Atom a -> Atom a
$ctanh :: forall a. Floating a => Atom a -> Atom a
cosh :: Atom a -> Atom a
$ccosh :: forall a. Floating a => Atom a -> Atom a
sinh :: Atom a -> Atom a
$csinh :: forall a. Floating a => Atom a -> Atom a
atan :: Atom a -> Atom a
$catan :: forall a. Floating a => Atom a -> Atom a
acos :: Atom a -> Atom a
$cacos :: forall a. Floating a => Atom a -> Atom a
asin :: Atom a -> Atom a
$casin :: forall a. Floating a => Atom a -> Atom a
tan :: Atom a -> Atom a
$ctan :: forall a. Floating a => Atom a -> Atom a
cos :: Atom a -> Atom a
$ccos :: forall a. Floating a => Atom a -> Atom a
sin :: Atom a -> Atom a
$csin :: forall a. Floating a => Atom a -> Atom a
logBase :: Atom a -> Atom a -> Atom a
$clogBase :: forall a. Floating a => Atom a -> Atom a -> Atom a
** :: Atom a -> Atom a -> Atom a
$c** :: forall a. Floating a => Atom a -> Atom a -> Atom a
sqrt :: Atom a -> Atom a
$csqrt :: forall a. Floating a => Atom a -> Atom a
log :: Atom a -> Atom a
$clog :: forall a. Floating a => Atom a -> Atom a
exp :: Atom a -> Atom a
$cexp :: forall a. Floating a => Atom a -> Atom a
pi :: Atom a
$cpi :: forall a. Floating a => Atom a
$cp1Floating :: forall a. Floating a => Fractional (Atom a)
Floating
           , Floating (Atom a)
RealFrac (Atom a)
RealFrac (Atom a)
-> Floating (Atom a)
-> (Atom a -> Integer)
-> (Atom a -> Int)
-> (Atom a -> (Int, Int))
-> (Atom a -> (Integer, Int))
-> (Integer -> Int -> Atom a)
-> (Atom a -> Int)
-> (Atom a -> Atom a)
-> (Int -> Atom a -> Atom a)
-> (Atom a -> Bool)
-> (Atom a -> Bool)
-> (Atom a -> Bool)
-> (Atom a -> Bool)
-> (Atom a -> Bool)
-> (Atom a -> Atom a -> Atom a)
-> RealFloat (Atom a)
Int -> Atom a -> Atom a
Integer -> Int -> Atom a
Atom a -> Bool
Atom a -> Int
Atom a -> Integer
Atom a -> (Int, Int)
Atom a -> (Integer, Int)
Atom a -> Atom a
Atom a -> Atom a -> Atom a
forall a. RealFloat a => Floating (Atom a)
forall a. RealFloat a => RealFrac (Atom a)
forall a. RealFloat a => Int -> Atom a -> Atom a
forall a. RealFloat a => Integer -> Int -> Atom a
forall a. RealFloat a => Atom a -> Bool
forall a. RealFloat a => Atom a -> Int
forall a. RealFloat a => Atom a -> Integer
forall a. RealFloat a => Atom a -> (Int, Int)
forall a. RealFloat a => Atom a -> (Integer, Int)
forall a. RealFloat a => Atom a -> Atom a
forall a. RealFloat a => Atom a -> Atom a -> Atom a
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: Atom a -> Atom a -> Atom a
$catan2 :: forall a. RealFloat a => Atom a -> Atom a -> Atom a
isIEEE :: Atom a -> Bool
$cisIEEE :: forall a. RealFloat a => Atom a -> Bool
isNegativeZero :: Atom a -> Bool
$cisNegativeZero :: forall a. RealFloat a => Atom a -> Bool
isDenormalized :: Atom a -> Bool
$cisDenormalized :: forall a. RealFloat a => Atom a -> Bool
isInfinite :: Atom a -> Bool
$cisInfinite :: forall a. RealFloat a => Atom a -> Bool
isNaN :: Atom a -> Bool
$cisNaN :: forall a. RealFloat a => Atom a -> Bool
scaleFloat :: Int -> Atom a -> Atom a
$cscaleFloat :: forall a. RealFloat a => Int -> Atom a -> Atom a
significand :: Atom a -> Atom a
$csignificand :: forall a. RealFloat a => Atom a -> Atom a
exponent :: Atom a -> Int
$cexponent :: forall a. RealFloat a => Atom a -> Int
encodeFloat :: Integer -> Int -> Atom a
$cencodeFloat :: forall a. RealFloat a => Integer -> Int -> Atom a
decodeFloat :: Atom a -> (Integer, Int)
$cdecodeFloat :: forall a. RealFloat a => Atom a -> (Integer, Int)
floatRange :: Atom a -> (Int, Int)
$cfloatRange :: forall a. RealFloat a => Atom a -> (Int, Int)
floatDigits :: Atom a -> Int
$cfloatDigits :: forall a. RealFloat a => Atom a -> Int
floatRadix :: Atom a -> Integer
$cfloatRadix :: forall a. RealFloat a => Atom a -> Integer
$cp2RealFloat :: forall a. RealFloat a => Floating (Atom a)
$cp1RealFloat :: forall a. RealFloat a => RealFrac (Atom a)
RealFloat
           , Eq (Atom a)
Atom a
Eq (Atom a)
-> (Atom a -> Atom a -> Atom a)
-> (Atom a -> Atom a -> Atom a)
-> (Atom a -> Atom a -> Atom a)
-> (Atom a -> Atom a)
-> (Atom a -> Int -> Atom a)
-> (Atom a -> Int -> Atom a)
-> Atom a
-> (Int -> Atom a)
-> (Atom a -> Int -> Atom a)
-> (Atom a -> Int -> Atom a)
-> (Atom a -> Int -> Atom a)
-> (Atom a -> Int -> Bool)
-> (Atom a -> Maybe Int)
-> (Atom a -> Int)
-> (Atom a -> Bool)
-> (Atom a -> Int -> Atom a)
-> (Atom a -> Int -> Atom a)
-> (Atom a -> Int -> Atom a)
-> (Atom a -> Int -> Atom a)
-> (Atom a -> Int -> Atom a)
-> (Atom a -> Int -> Atom a)
-> (Atom a -> Int)
-> Bits (Atom a)
Int -> Atom a
Atom a -> Bool
Atom a -> Int
Atom a -> Maybe Int
Atom a -> Atom a
Atom a -> Int -> Bool
Atom a -> Int -> Atom a
Atom a -> Atom a -> Atom a
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
forall a. Bits a => Eq (Atom a)
forall a. Bits a => Atom a
forall a. Bits a => Int -> Atom a
forall a. Bits a => Atom a -> Bool
forall a. Bits a => Atom a -> Int
forall a. Bits a => Atom a -> Maybe Int
forall a. Bits a => Atom a -> Atom a
forall a. Bits a => Atom a -> Int -> Bool
forall a. Bits a => Atom a -> Int -> Atom a
forall a. Bits a => Atom a -> Atom a -> Atom a
popCount :: Atom a -> Int
$cpopCount :: forall a. Bits a => Atom a -> Int
rotateR :: Atom a -> Int -> Atom a
$crotateR :: forall a. Bits a => Atom a -> Int -> Atom a
rotateL :: Atom a -> Int -> Atom a
$crotateL :: forall a. Bits a => Atom a -> Int -> Atom a
unsafeShiftR :: Atom a -> Int -> Atom a
$cunsafeShiftR :: forall a. Bits a => Atom a -> Int -> Atom a
shiftR :: Atom a -> Int -> Atom a
$cshiftR :: forall a. Bits a => Atom a -> Int -> Atom a
unsafeShiftL :: Atom a -> Int -> Atom a
$cunsafeShiftL :: forall a. Bits a => Atom a -> Int -> Atom a
shiftL :: Atom a -> Int -> Atom a
$cshiftL :: forall a. Bits a => Atom a -> Int -> Atom a
isSigned :: Atom a -> Bool
$cisSigned :: forall a. Bits a => Atom a -> Bool
bitSize :: Atom a -> Int
$cbitSize :: forall a. Bits a => Atom a -> Int
bitSizeMaybe :: Atom a -> Maybe Int
$cbitSizeMaybe :: forall a. Bits a => Atom a -> Maybe Int
testBit :: Atom a -> Int -> Bool
$ctestBit :: forall a. Bits a => Atom a -> Int -> Bool
complementBit :: Atom a -> Int -> Atom a
$ccomplementBit :: forall a. Bits a => Atom a -> Int -> Atom a
clearBit :: Atom a -> Int -> Atom a
$cclearBit :: forall a. Bits a => Atom a -> Int -> Atom a
setBit :: Atom a -> Int -> Atom a
$csetBit :: forall a. Bits a => Atom a -> Int -> Atom a
bit :: Int -> Atom a
$cbit :: forall a. Bits a => Int -> Atom a
zeroBits :: Atom a
$czeroBits :: forall a. Bits a => Atom a
rotate :: Atom a -> Int -> Atom a
$crotate :: forall a. Bits a => Atom a -> Int -> Atom a
shift :: Atom a -> Int -> Atom a
$cshift :: forall a. Bits a => Atom a -> Int -> Atom a
complement :: Atom a -> Atom a
$ccomplement :: forall a. Bits a => Atom a -> Atom a
xor :: Atom a -> Atom a -> Atom a
$cxor :: forall a. Bits a => Atom a -> Atom a -> Atom a
.|. :: Atom a -> Atom a -> Atom a
$c.|. :: forall a. Bits a => Atom a -> Atom a -> Atom a
.&. :: Atom a -> Atom a -> Atom a
$c.&. :: forall a. Bits a => Atom a -> Atom a -> Atom a
$cp1Bits :: forall a. Bits a => Eq (Atom a)
Bits
           , Atom a -> ()
(Atom a -> ()) -> NFData (Atom a)
forall a. NFData a => Atom a -> ()
forall a. (a -> ()) -> NFData a
rnf :: Atom a -> ()
$crnf :: forall a. NFData a => Atom a -> ()
NFData
           )


instance Prim a => Prim (Atom a) where
  type PrimBase (Atom a) = Atom a
  type SizeOf (Atom a) = 1 + SizeOf a
  type Alignment (Atom a) = 1 + Alignment a
  sizeOf# :: Proxy# (Atom a) -> Int#
sizeOf# Proxy# (Atom a)
_ = Int#
1# Int# -> Int# -> Int#
+# Proxy# a -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# a
forall k (a :: k). Proxy# a
proxy# :: Proxy# a)
  {-# INLINE sizeOf# #-}
  alignment# :: Proxy# (Atom a) -> Int#
alignment# Proxy# (Atom a)
_ = Int#
1# Int# -> Int# -> Int#
+# Proxy# a -> Int#
forall a. Prim a => Proxy# a -> Int#
alignment# (Proxy# a
forall k (a :: k). Proxy# a
proxy# :: Proxy# a)
  {-# INLINE alignment# #-}
  indexByteOffByteArray# :: ByteArray# -> Int# -> Atom a
indexByteOffByteArray# ByteArray#
ba# Int#
i# = a -> Atom a
forall a. a -> Atom a
Atom (ByteArray# -> Int# -> a
forall a. Prim a => ByteArray# -> Int# -> a
indexByteOffByteArray# ByteArray#
ba# (Int#
1# Int# -> Int# -> Int#
+# Int#
i#))
  {-# INLINE indexByteOffByteArray# #-}
  indexByteArray# :: ByteArray# -> Int# -> Atom a
indexByteArray# ByteArray#
ba# Int#
i# = ByteArray# -> Int# -> Atom a
forall a. Prim a => ByteArray# -> Int# -> a
indexByteOffByteArray# ByteArray#
ba# (Int#
i# Int# -> Int# -> Int#
*# Proxy# (Atom a) -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# (Atom a)
forall k (a :: k). Proxy# a
proxy# :: Proxy# (Atom a)))
  {-# INLINE indexByteArray# #-}
  indexOffAddr# :: Addr# -> Int# -> Atom a
indexOffAddr# Addr#
addr# Int#
i# =
    a -> Atom a
forall a. a -> Atom a
Atom (Addr# -> Int# -> a
forall a. Prim a => Addr# -> Int# -> a
indexOffAddr# (Addr#
addr# Addr# -> Int# -> Addr#
`plusAddr#` (Int#
1# Int# -> Int# -> Int#
+# Int#
i# Int# -> Int# -> Int#
*# Proxy# (Atom a) -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# (Atom a)
forall k (a :: k). Proxy# a
proxy# :: Proxy# (Atom a)))) Int#
0#)
  {-# INLINE indexOffAddr# #-}
  readByteOffMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Atom a #)
readByteOffMutableByteArray# MutableByteArray# s
mba# Int#
i# State# s
s =
    case MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
readByteOffMutableByteArray# MutableByteArray# s
mba# (Int#
1# Int# -> Int# -> Int#
+# Int#
i#) State# s
s of
      (# State# s
s', a
a #) -> (# State# s
s', a -> Atom a
forall a. a -> Atom a
Atom a
a #)
  {-# INLINE readByteOffMutableByteArray# #-}
  readMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Atom a #)
readMutableByteArray# MutableByteArray# s
mba# Int#
i# =
    MutableByteArray# s -> Int# -> State# s -> (# State# s, Atom a #)
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
readByteOffMutableByteArray# MutableByteArray# s
mba# (Int#
i# Int# -> Int# -> Int#
*# Proxy# (Atom a) -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# (Atom a)
forall k (a :: k). Proxy# a
proxy# :: Proxy# (Atom a)))
  {-# INLINE readMutableByteArray# #-}
  readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Atom a #)
readOffAddr# Addr#
addr# Int#
i# State# s
s =
    case Addr# -> Int# -> State# s -> (# State# s, a #)
forall a s.
Prim a =>
Addr# -> Int# -> State# s -> (# State# s, a #)
readOffAddr# (Addr#
addr# Addr# -> Int# -> Addr#
`plusAddr#` (Int#
1# Int# -> Int# -> Int#
+# Int#
i# Int# -> Int# -> Int#
*# Proxy# (Atom a) -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# (Atom a)
forall k (a :: k). Proxy# a
proxy# :: Proxy# (Atom a)))) Int#
0# State# s
s of
      (# State# s
s', a
a #) -> (# State# s
s', a -> Atom a
forall a. a -> Atom a
Atom a
a #)
  {-# INLINE readOffAddr# #-}
  writeByteOffMutableByteArray# :: MutableByteArray# s -> Int# -> Atom a -> State# s -> State# s
writeByteOffMutableByteArray# MutableByteArray# s
mba# Int#
i# (Atom a
a) State# s
s =
    MutableByteArray# s -> Int# -> Word8 -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> a -> State# s -> State# s
writeByteOffMutableByteArray# MutableByteArray# s
mba# Int#
i# (Word8
0 :: Word8)
      (MutableByteArray# s -> Int# -> a -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> a -> State# s -> State# s
writeByteOffMutableByteArray# MutableByteArray# s
mba# (Int#
1# Int# -> Int# -> Int#
+# Int#
i#) a
a State# s
s)
  {-# INLINE writeByteOffMutableByteArray# #-}
  writeMutableByteArray# :: MutableByteArray# s -> Int# -> Atom a -> State# s -> State# s
writeMutableByteArray# MutableByteArray# s
mba# Int#
i# (Atom a
a) State# s
s =
    let i0# :: Int#
i0# = Int#
i# Int# -> Int# -> Int#
*# Proxy# (Atom a) -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# (Atom a)
forall k (a :: k). Proxy# a
proxy# :: Proxy# (Atom a))
    in MutableByteArray# s -> Int# -> Word8 -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> a -> State# s -> State# s
writeByteOffMutableByteArray# MutableByteArray# s
mba# Int#
i0# (Word8
0 :: Word8)
         (MutableByteArray# s -> Int# -> a -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> a -> State# s -> State# s
writeByteOffMutableByteArray# MutableByteArray# s
mba# (Int#
1# Int# -> Int# -> Int#
+# Int#
i0#) a
a State# s
s)
  {-# INLINE writeMutableByteArray# #-}
  writeOffAddr# :: Addr# -> Int# -> Atom a -> State# s -> State# s
writeOffAddr# Addr#
addr# Int#
i# (Atom a
a) State# s
s =
    let i0# :: Int#
i0# = Int#
i# Int# -> Int# -> Int#
*# Proxy# (Atom a) -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# (Atom a)
forall k (a :: k). Proxy# a
proxy# :: Proxy# (Atom a))
    in Addr# -> Int# -> Word8 -> State# s -> State# s
forall a s. Prim a => Addr# -> Int# -> a -> State# s -> State# s
writeOffAddr# Addr#
addr# Int#
i0# (Word8
0 :: Word8) (Addr# -> Int# -> a -> State# s -> State# s
forall a s. Prim a => Addr# -> Int# -> a -> State# s -> State# s
writeOffAddr# (Addr#
addr# Addr# -> Int# -> Addr#
`plusAddr#` (Int#
1# Int# -> Int# -> Int#
+# Int#
i0#)) Int#
0# a
a State# s
s)
  {-# INLINE writeOffAddr# #-}
  setMutableByteArray# :: MutableByteArray# s
-> Int# -> Int# -> Atom a -> State# s -> State# s
setMutableByteArray# = MutableByteArray# s
-> Int# -> Int# -> Atom a -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s
setMutableByteArrayLoop#
  {-# INLINE setMutableByteArray# #-}
  setOffAddr# :: Addr# -> Int# -> Int# -> Atom a -> State# s -> State# s
setOffAddr# = Addr# -> Int# -> Int# -> Atom a -> State# s -> State# s
forall a s.
Prim a =>
Addr# -> Int# -> Int# -> a -> State# s -> State# s
setOffAddrLoop#
  {-# INLINE setOffAddr# #-}


acquireLockByteOffMutableByteArray :: MonadPrim s m => MutableByteArray# s -> Int# -> m ()
acquireLockByteOffMutableByteArray :: MutableByteArray# s -> Int# -> m ()
acquireLockByteOffMutableByteArray MutableByteArray# s
mba# Int#
i# =
  let go :: m ()
go = do
        Int8
locked <- IO Int8 -> m Int8
forall s (m :: * -> *) a. MonadPrim s m => IO a -> m a
unsafeIOToPrim (IO Int8 -> m Int8) -> IO Int8 -> m Int8
forall a b. (a -> b) -> a -> b
$ MutableByteArray# s -> Int# -> IO Int8
forall s. MutableByteArray# s -> Int# -> IO Int8
syncLockTestSetInt8ArrayIO MutableByteArray# s
mba# Int#
i#
        Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Int8
locked Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
0) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ m ()
forall (m :: * -> *) s. MonadPrim s m => m ()
yield m () -> m () -> m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ()
go
   in m ()
go
{-# INLINE acquireLockByteOffMutableByteArray #-}

releaseLockByteOffMutableByteArray :: MonadPrim s m => MutableByteArray# s -> Int# -> m ()
releaseLockByteOffMutableByteArray :: MutableByteArray# s -> Int# -> m ()
releaseLockByteOffMutableByteArray MutableByteArray# s
mba# Int#
i# =
  IO () -> m ()
forall s (m :: * -> *) a. MonadPrim s m => IO a -> m a
unsafeIOToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MutableByteArray# s -> Int# -> IO ()
forall s. MutableByteArray# s -> Int# -> IO ()
syncLockReleaseInt8ArrayIO MutableByteArray# s
mba# Int#
i#
{-# INLINE releaseLockByteOffMutableByteArray #-}


acquireLockByteOffAddr :: MonadPrim s m => Addr# -> Int# -> m ()
acquireLockByteOffAddr :: Addr# -> Int# -> m ()
acquireLockByteOffAddr Addr#
addr# Int#
i# =
  let go :: m ()
go = do
        Int8
locked <- IO Int8 -> m Int8
forall s (m :: * -> *) a. MonadPrim s m => IO a -> m a
unsafeIOToPrim (IO Int8 -> m Int8) -> IO Int8 -> m Int8
forall a b. (a -> b) -> a -> b
$ Addr# -> Int# -> IO Int8
syncLockTestSetInt8AddrIO Addr#
addr# Int#
i#
        Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Int8
locked Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
0) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ m ()
forall (m :: * -> *) s. MonadPrim s m => m ()
yield m () -> m () -> m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ()
go
   in m ()
go
{-# INLINE acquireLockByteOffAddr #-}

releaseLockByteOffAddr :: MonadPrim s m => Addr#-> Int# -> m ()
releaseLockByteOffAddr :: Addr# -> Int# -> m ()
releaseLockByteOffAddr Addr#
addr# Int#
i# = IO () -> m ()
forall s (m :: * -> *) a. MonadPrim s m => IO a -> m a
unsafeIOToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Addr# -> Int# -> IO ()
syncLockReleaseInt8AddrIO Addr#
addr# Int#
i#
{-# INLINE releaseLockByteOffAddr #-}

withLockMutableByteArray ::
     forall e a m. (Prim e, MonadUnliftPrim RW m)
  => MutableByteArray# RealWorld
  -> Int#
  -> (Atom e -> m (Atom e, a))
  -> m a
withLockMutableByteArray :: MutableByteArray# RealWorld
-> Int# -> (Atom e -> m (Atom e, a)) -> m a
withLockMutableByteArray MutableByteArray# RealWorld
mba# Int#
i# Atom e -> m (Atom e, a)
f =
  let li0# :: Int#
li0# = Int#
i# Int# -> Int# -> Int#
*# Proxy# (Atom e) -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# (Atom e)
forall k (a :: k). Proxy# a
proxy# :: Proxy# (Atom e))
      li# :: Int#
li# = Int#
1# Int# -> Int# -> Int#
+# Int#
li0#
   in m () -> m () -> m a -> m a
forall (m :: * -> *) a b c.
MonadUnliftPrim RealWorld m =>
m a -> m b -> m c -> m c
bracket_
        (MutableByteArray# RealWorld -> Int# -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
MutableByteArray# s -> Int# -> m ()
acquireLockByteOffMutableByteArray MutableByteArray# RealWorld
mba# Int#
li0#)
        (MutableByteArray# RealWorld -> Int# -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
MutableByteArray# s -> Int# -> m ()
releaseLockByteOffMutableByteArray MutableByteArray# RealWorld
mba# Int#
li0#) (m a -> m a) -> m a -> m a
forall a b. (a -> b) -> a -> b
$ do
      e
a <- (State# RealWorld -> (# State# RealWorld, e #)) -> m e
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim (MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, e #)
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
readByteOffMutableByteArray# MutableByteArray# RealWorld
mba# Int#
li#)
      (Atom e
a', a
b) <- Atom e -> m (Atom e, a)
f (e -> Atom e
forall a. a -> Atom a
Atom e
a)
      a
b a -> m () -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (State# RealWorld -> State# RealWorld) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (MutableByteArray# RealWorld
-> Int# -> e -> State# RealWorld -> State# RealWorld
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> a -> State# s -> State# s
writeByteOffMutableByteArray# MutableByteArray# RealWorld
mba# Int#
li# e
a')
{-# INLINABLE withLockMutableByteArray #-}


-- | Atomic reads on `Atom` require a lock because otherwise any other thread can
-- overwrite the contnts in the midst of reading, resulting in a value with contents
-- from both values part before and part after the write.
atomicReadAtomMutableByteArray ::
     forall e m s. (Prim e, MonadPrim s m)
  => MutableByteArray# s
  -> Int#
  -> m (Atom e)
atomicReadAtomMutableByteArray :: MutableByteArray# s -> Int# -> m (Atom e)
atomicReadAtomMutableByteArray MutableByteArray# s
mba# Int#
i# =
  let li# :: Int#
li# = Int#
i# Int# -> Int# -> Int#
*# Proxy# (Atom e) -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# (Atom e)
forall k (a :: k). Proxy# a
proxy# :: Proxy# (Atom e))
   in ST s (Atom e) -> m (Atom e)
forall a (n :: * -> *) (m :: * -> *) s.
(MonadPrimBase s n, MonadPrim s m) =>
n a -> m a
uninterruptibleMaskPrimBase_ (ST s (Atom e) -> m (Atom e)) -> ST s (Atom e) -> m (Atom e)
forall a b. (a -> b) -> a -> b
$ do
        MutableByteArray# s -> Int# -> ST s ()
forall s (m :: * -> *).
MonadPrim s m =>
MutableByteArray# s -> Int# -> m ()
acquireLockByteOffMutableByteArray MutableByteArray# s
mba# Int#
li#
        e
r :: e <- STRep s e -> ST s e
forall s a. STRep s a -> ST s a
ST (MutableByteArray# s -> Int# -> STRep s e
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
readByteOffMutableByteArray# MutableByteArray# s
mba# (Int#
1# Int# -> Int# -> Int#
+# Int#
li#))
        e -> Atom e
coerce e
r Atom e -> ST s () -> ST s (Atom e)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ MutableByteArray# s -> Int# -> ST s ()
forall s (m :: * -> *).
MonadPrim s m =>
MutableByteArray# s -> Int# -> m ()
releaseLockByteOffMutableByteArray MutableByteArray# s
mba# Int#
li#
{-# INLINABLE atomicReadAtomMutableByteArray #-}

-- | Values are no longer guaranteed to be one word in size, as such in order for writes
-- to be atomic we require locking.
atomicWriteAtomMutableByteArray ::
     forall e m s. (Prim e, MonadPrim s m)
  => MutableByteArray# s
  -> Int#
  -> Atom e
  -> m ()
atomicWriteAtomMutableByteArray :: MutableByteArray# s -> Int# -> Atom e -> m ()
atomicWriteAtomMutableByteArray MutableByteArray# s
mba# Int#
i# (Atom e
a) =
  let li# :: Int#
li# = Int#
i# Int# -> Int# -> Int#
*# Proxy# (Atom e) -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# (Atom e)
forall k (a :: k). Proxy# a
proxy# :: Proxy# (Atom e))
   in ST s () -> m ()
forall a (n :: * -> *) (m :: * -> *) s.
(MonadPrimBase s n, MonadPrim s m) =>
n a -> m a
uninterruptibleMaskPrimBase_ (ST s () -> m ()) -> ST s () -> m ()
forall a b. (a -> b) -> a -> b
$ do
        MutableByteArray# s -> Int# -> ST s ()
forall s (m :: * -> *).
MonadPrim s m =>
MutableByteArray# s -> Int# -> m ()
acquireLockByteOffMutableByteArray MutableByteArray# s
mba# Int#
li#
        (State# s -> State# s) -> ST s ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (MutableByteArray# s -> Int# -> e -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> a -> State# s -> State# s
writeByteOffMutableByteArray# MutableByteArray# s
mba# (Int#
1# Int# -> Int# -> Int#
+# Int#
li#) e
a)
        MutableByteArray# s -> Int# -> ST s ()
forall s (m :: * -> *).
MonadPrim s m =>
MutableByteArray# s -> Int# -> m ()
releaseLockByteOffMutableByteArray MutableByteArray# s
mba# Int#
li# :: ST s ()
{-# INLINABLE atomicWriteAtomMutableByteArray #-}



-- | Same as `atomicReadAtomMutableByteArray`, but for `Addr#` with offset
atomicReadAtomOffAddr ::
     forall e m s. (Prim e, MonadPrim s m)
  => Addr#
  -> Int#
  -> m (Atom e)
atomicReadAtomOffAddr :: Addr# -> Int# -> m (Atom e)
atomicReadAtomOffAddr Addr#
mba# Int#
i# =
  let li# :: Int#
li# = Int#
i# Int# -> Int# -> Int#
*# Proxy# (Atom e) -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# (Atom e)
forall k (a :: k). Proxy# a
proxy# :: Proxy# (Atom e))
   in ST s (Atom e) -> m (Atom e)
forall a (n :: * -> *) (m :: * -> *) s.
(MonadPrimBase s n, MonadPrim s m) =>
n a -> m a
uninterruptibleMaskPrimBase_ (ST s (Atom e) -> m (Atom e)) -> ST s (Atom e) -> m (Atom e)
forall a b. (a -> b) -> a -> b
$ do
        Addr# -> Int# -> ST s ()
forall s (m :: * -> *). MonadPrim s m => Addr# -> Int# -> m ()
acquireLockByteOffAddr Addr#
mba# Int#
li#
        e
r :: e <- STRep s e -> ST s e
forall s a. STRep s a -> ST s a
ST (Addr# -> Int# -> STRep s e
forall a s.
Prim a =>
Addr# -> Int# -> State# s -> (# State# s, a #)
readOffAddr# Addr#
mba# (Int#
1# Int# -> Int# -> Int#
+# Int#
li#))
        e -> Atom e
coerce e
r Atom e -> ST s () -> ST s (Atom e)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Addr# -> Int# -> ST s ()
forall s (m :: * -> *). MonadPrim s m => Addr# -> Int# -> m ()
releaseLockByteOffAddr Addr#
mba# Int#
li#
{-# INLINABLE atomicReadAtomOffAddr #-}

-- | Same as `atomicWriteAtomMutableByteArray`, but for `Addr#` with offset
atomicWriteAtomOffAddr ::
     forall e m s. (Prim e, MonadPrim s m)
  => Addr#
  -> Int#
  -> Atom e
  -> m ()
atomicWriteAtomOffAddr :: Addr# -> Int# -> Atom e -> m ()
atomicWriteAtomOffAddr Addr#
addr# Int#
i# (Atom e
a) =
  let li# :: Int#
li# = Int#
i# Int# -> Int# -> Int#
*# Proxy# (Atom e) -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# (Atom e)
forall k (a :: k). Proxy# a
proxy# :: Proxy# (Atom e))
      lockAddr# :: Addr#
lockAddr# = Addr#
addr# Addr# -> Int# -> Addr#
`plusAddr#` Int#
li#
      valAddr# :: Addr#
valAddr# = Addr#
lockAddr# Addr# -> Int# -> Addr#
`plusAddr#` Int#
1#
   in ST s () -> m ()
forall a (n :: * -> *) (m :: * -> *) s.
(MonadPrimBase s n, MonadPrim s m) =>
n a -> m a
uninterruptibleMaskPrimBase_ (ST s () -> m ()) -> ST s () -> m ()
forall a b. (a -> b) -> a -> b
$ do
        Addr# -> Int# -> ST s ()
forall s (m :: * -> *). MonadPrim s m => Addr# -> Int# -> m ()
acquireLockByteOffAddr Addr#
lockAddr# Int#
0#
        (State# s -> State# s) -> ST s ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (Addr# -> Int# -> e -> State# s -> State# s
forall a s. Prim a => Addr# -> Int# -> a -> State# s -> State# s
writeOffAddr# Addr#
valAddr# Int#
0# e
a)
        Addr# -> Int# -> ST s ()
forall s (m :: * -> *). MonadPrim s m => Addr# -> Int# -> m ()
releaseLockByteOffAddr Addr#
lockAddr# Int#
0# :: ST s ()
{-# INLINABLE atomicWriteAtomOffAddr #-}



withLockOffAddr ::
     forall e b. Prim e
  => Addr#
  -> Int#
  -> (Atom e -> IO (Atom e, b))
  -> IO b
withLockOffAddr :: Addr# -> Int# -> (Atom e -> IO (Atom e, b)) -> IO b
withLockOffAddr Addr#
addr# Int#
i# Atom e -> IO (Atom e, b)
f =
  let li# :: Int#
li# = Int#
i# Int# -> Int# -> Int#
*# Proxy# (Atom e) -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# (Atom e)
forall k (a :: k). Proxy# a
proxy# :: Proxy# (Atom e))
      offAddr# :: Addr#
offAddr# = Addr#
addr# Addr# -> Int# -> Addr#
`plusAddr#` (Int#
1# Int# -> Int# -> Int#
+# Int#
li#)
   in IO () -> IO () -> IO b -> IO b
forall (m :: * -> *) a b c.
MonadUnliftPrim RealWorld m =>
m a -> m b -> m c -> m c
bracket_
        (Addr# -> Int# -> IO ()
forall s (m :: * -> *). MonadPrim s m => Addr# -> Int# -> m ()
acquireLockByteOffAddr Addr#
addr# Int#
li#)
        (Addr# -> Int# -> IO ()
forall s (m :: * -> *). MonadPrim s m => Addr# -> Int# -> m ()
releaseLockByteOffAddr Addr#
addr# Int#
li#) (IO b -> IO b) -> IO b -> IO b
forall a b. (a -> b) -> a -> b
$ do
      e
a <- (State# RealWorld -> (# State# RealWorld, e #)) -> IO e
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim (Addr# -> Int# -> State# RealWorld -> (# State# RealWorld, e #)
forall a s.
Prim a =>
Addr# -> Int# -> State# s -> (# State# s, a #)
readOffAddr# Addr#
offAddr# Int#
0#)
      (Atom e
a', b
b) <- Atom e -> IO (Atom e, b)
f (e -> Atom e
forall a. a -> Atom a
Atom e
a)
      b
b b -> IO () -> IO b
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (State# RealWorld -> State# RealWorld) -> IO ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (Addr# -> Int# -> e -> State# RealWorld -> State# RealWorld
forall a s. Prim a => Addr# -> Int# -> a -> State# s -> State# s
writeOffAddr# Addr#
offAddr# Int#
0# e
a')
{-# INLINABLE withLockOffAddr #-}


atomicModifyAtomMutableByteArray ::
     forall e a m s. (Prim e, MonadPrim s m)
  => MutableByteArray# s
  -> Int#
  -> (Atom e -> (# Atom e, a #))
  -> m a
atomicModifyAtomMutableByteArray :: MutableByteArray# s -> Int# -> (Atom e -> (# Atom e, a #)) -> m a
atomicModifyAtomMutableByteArray MutableByteArray# s
mba# Int#
i# Atom e -> (# Atom e, a #)
f =
  let li# :: Int#
li# = Int#
i# Int# -> Int# -> Int#
*# Proxy# (Atom e) -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# (Atom e)
forall k (a :: k). Proxy# a
proxy# :: Proxy# (Atom e))
   in ST s a -> m a
forall a (n :: * -> *) (m :: * -> *) s.
(MonadPrimBase s n, MonadPrim s m) =>
n a -> m a
uninterruptibleMaskPrimBase_ (ST s a -> m a) -> ST s a -> m a
forall a b. (a -> b) -> a -> b
$ do
        MutableByteArray# s -> Int# -> ST s ()
forall s (m :: * -> *).
MonadPrim s m =>
MutableByteArray# s -> Int# -> m ()
acquireLockByteOffMutableByteArray MutableByteArray# s
mba# Int#
li#
        a
r <- STRep s a -> ST s a
forall s a. STRep s a -> ST s a
ST (STRep s a -> ST s a) -> STRep s a -> ST s a
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
          case MutableByteArray# s -> Int# -> State# s -> (# State# s, e #)
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
readByteOffMutableByteArray# MutableByteArray# s
mba# (Int#
1# Int# -> Int# -> Int#
+# Int#
li#) State# s
s of
            (# State# s
s', e
a #) ->
              case Atom e -> (# Atom e, a #)
f (e -> Atom e
forall a. a -> Atom a
Atom e
a) of
                (# Atom e
a', a
b #) ->
                  (# MutableByteArray# s -> Int# -> e -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> a -> State# s -> State# s
writeByteOffMutableByteArray# MutableByteArray# s
mba# (Int#
1# Int# -> Int# -> Int#
+# Int#
li#) e
a' State# s
s', a
b #)
        a
r a -> ST s () -> ST s a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ MutableByteArray# s -> Int# -> ST s ()
forall s (m :: * -> *).
MonadPrim s m =>
MutableByteArray# s -> Int# -> m ()
releaseLockByteOffMutableByteArray MutableByteArray# s
mba# Int#
li#
{-# INLINE atomicModifyAtomMutableByteArray  #-}

atomicModifyAtomOffAddr ::
     forall e a m s. (Prim e, MonadPrim s m)
  => Addr#
  -> Int#
  -> (Atom e -> (# Atom e, a #))
  -> m a
atomicModifyAtomOffAddr :: Addr# -> Int# -> (Atom e -> (# Atom e, a #)) -> m a
atomicModifyAtomOffAddr Addr#
addr# Int#
i# Atom e -> (# Atom e, a #)
f =
  let li# :: Int#
li# = Int#
i# Int# -> Int# -> Int#
*# Proxy# (Atom e) -> Int#
forall a. Prim a => Proxy# a -> Int#
sizeOf# (Proxy# (Atom e)
forall k (a :: k). Proxy# a
proxy# :: Proxy# (Atom e))
      offAddr# :: Addr#
offAddr# = Addr#
addr# Addr# -> Int# -> Addr#
`plusAddr#` (Int#
1# Int# -> Int# -> Int#
+# Int#
li#)
   in ST s a -> m a
forall a (n :: * -> *) (m :: * -> *) s.
(MonadPrimBase s n, MonadPrim s m) =>
n a -> m a
uninterruptibleMaskPrimBase_ (ST s a -> m a) -> ST s a -> m a
forall a b. (a -> b) -> a -> b
$ do
        Addr# -> Int# -> ST s ()
forall s (m :: * -> *). MonadPrim s m => Addr# -> Int# -> m ()
acquireLockByteOffAddr Addr#
addr# Int#
li#
        a
r <- STRep s a -> ST s a
forall s a. STRep s a -> ST s a
ST (STRep s a -> ST s a) -> STRep s a -> ST s a
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
          case Addr# -> Int# -> State# s -> (# State# s, e #)
forall a s.
Prim a =>
Addr# -> Int# -> State# s -> (# State# s, a #)
readOffAddr# Addr#
offAddr# Int#
0# State# s
s of
            (# State# s
s', e
a #) ->
              case Atom e -> (# Atom e, a #)
f (e -> Atom e
forall a. a -> Atom a
Atom e
a) of
                (# Atom e
a', a
b #) ->
                  (# Addr# -> Int# -> e -> State# s -> State# s
forall a s. Prim a => Addr# -> Int# -> a -> State# s -> State# s
writeOffAddr# Addr#
offAddr# Int#
0# e
a' State# s
s', a
b #)
        a
r a -> ST s () -> ST s a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Addr# -> Int# -> ST s ()
forall s (m :: * -> *). MonadPrim s m => Addr# -> Int# -> m ()
releaseLockByteOffAddr Addr#
addr# Int#
li#
{-# INLINE atomicModifyAtomOffAddr #-}


swapIfEqualVal :: Eq e => Atom e -> Atom e -> Atom e -> (# Atom e, Atom e #)
swapIfEqualVal :: Atom e -> Atom e -> Atom e -> (# Atom e, Atom e #)
swapIfEqualVal Atom e
expected Atom e
new Atom e
actual
  | Atom e
expected Atom e -> Atom e -> Bool
forall a. Eq a => a -> a -> Bool
== Atom e
actual = (# Atom e
new, Atom e
actual #)
  | Bool
otherwise = (# Atom e
actual, Atom e
actual #)
{-# INLINE swapIfEqualVal #-}

swapIfEqualBool :: Eq e => Atom e -> Atom e -> Atom e -> (# Atom e, Bool #)
swapIfEqualBool :: Atom e -> Atom e -> Atom e -> (# Atom e, Bool #)
swapIfEqualBool Atom e
expected Atom e
new Atom e
actual
  | Atom e
expected Atom e -> Atom e -> Bool
forall a. Eq a => a -> a -> Bool
== Atom e
actual = (# Atom e
new, Bool
True #)
  | Bool
otherwise = (# Atom e
actual, Bool
False #)
{-# INLINE swapIfEqualBool #-}

instance (Eq a, Prim a) => Atomic (Atom a) where
  atomicReadMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Atom a #)
atomicReadMutableByteArray# MutableByteArray# s
mba# Int#
i# =
    ST s (Atom a) -> State# s -> (# State# s, Atom a #)
forall s a. ST s a -> State# s -> (# State# s, a #)
unST (MutableByteArray# s -> Int# -> ST s (Atom a)
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
MutableByteArray# s -> Int# -> m (Atom e)
atomicReadAtomMutableByteArray (MutableByteArray# s -> MutableByteArray# s
unsafeCoerce# MutableByteArray# s
mba#) Int#
i#)
  {-# INLINABLE atomicReadMutableByteArray# #-}
  atomicWriteMutableByteArray# :: MutableByteArray# s -> Int# -> Atom a -> State# s -> State# s
atomicWriteMutableByteArray# MutableByteArray# s
mba# Int#
i# Atom a
a =
    ST s () -> State# s -> State# s
forall s. ST s () -> State# s -> State# s
unST_ (MutableByteArray# s -> Int# -> Atom a -> ST s ()
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
MutableByteArray# s -> Int# -> Atom e -> m ()
atomicWriteAtomMutableByteArray (MutableByteArray# s -> MutableByteArray# s
unsafeCoerce# MutableByteArray# s
mba#) Int#
i# Atom a
a)
  {-# INLINABLE atomicWriteMutableByteArray# #-}
  atomicReadOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Atom a #)
atomicReadOffAddr# Addr#
addr# Int#
i# = ST s (Atom a) -> State# s -> (# State# s, Atom a #)
forall s a. ST s a -> State# s -> (# State# s, a #)
unST (Addr# -> Int# -> ST s (Atom a)
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Addr# -> Int# -> m (Atom e)
atomicReadAtomOffAddr Addr#
addr# Int#
i#)
  {-# INLINABLE atomicReadOffAddr# #-}
  atomicWriteOffAddr# :: Addr# -> Int# -> Atom a -> State# s -> State# s
atomicWriteOffAddr# Addr#
addr# Int#
i# Atom a
a = ST s () -> State# s -> State# s
forall s. ST s () -> State# s -> State# s
unST_ (Addr# -> Int# -> Atom a -> ST s ()
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Addr# -> Int# -> Atom e -> m ()
atomicWriteAtomOffAddr Addr#
addr# Int#
i# Atom a
a)
  {-# INLINABLE atomicWriteOffAddr# #-}
  casMutableByteArray# :: MutableByteArray# s
-> Int# -> Atom a -> Atom a -> State# s -> (# State# s, Atom a #)
casMutableByteArray# MutableByteArray# s
mba# Int#
i# Atom a
old Atom a
new =
    ST s (Atom a) -> State# s -> (# State# s, Atom a #)
forall s a. ST s a -> State# s -> (# State# s, a #)
unST (MutableByteArray# s
-> Int# -> (Atom a -> (# Atom a, Atom a #)) -> ST s (Atom a)
forall e a (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
MutableByteArray# s -> Int# -> (Atom e -> (# Atom e, a #)) -> m a
atomicModifyAtomMutableByteArray MutableByteArray# s
mba# Int#
i# (Atom a -> Atom a -> Atom a -> (# Atom a, Atom a #)
forall e.
Eq e =>
Atom e -> Atom e -> Atom e -> (# Atom e, Atom e #)
swapIfEqualVal Atom a
old Atom a
new))
  {-# INLINE casMutableByteArray# #-}
  casOffAddr# :: Addr#
-> Int# -> Atom a -> Atom a -> State# s -> (# State# s, Atom a #)
casOffAddr# Addr#
addr# Int#
i# Atom a
old Atom a
new =
    Addr#
-> Int#
-> (Atom a -> (# Atom a, Atom a #))
-> State# s
-> (# State# s, Atom a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (Atom a -> Atom a -> Atom a -> (# Atom a, Atom a #)
forall e.
Eq e =>
Atom e -> Atom e -> Atom e -> (# Atom e, Atom e #)
swapIfEqualVal Atom a
old Atom a
new)
  {-# INLINE casOffAddr# #-}
  casBoolMutableByteArray# :: MutableByteArray# s
-> Int# -> Atom a -> Atom a -> State# s -> (# State# s, Bool #)
casBoolMutableByteArray# MutableByteArray# s
mba# Int#
i# Atom a
old Atom a
new =
    ST s Bool -> State# s -> (# State# s, Bool #)
forall s a. ST s a -> State# s -> (# State# s, a #)
unST (MutableByteArray# s
-> Int# -> (Atom a -> (# Atom a, Bool #)) -> ST s Bool
forall e a (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
MutableByteArray# s -> Int# -> (Atom e -> (# Atom e, a #)) -> m a
atomicModifyAtomMutableByteArray MutableByteArray# s
mba# Int#
i# (Atom a -> Atom a -> Atom a -> (# Atom a, Bool #)
forall e. Eq e => Atom e -> Atom e -> Atom e -> (# Atom e, Bool #)
swapIfEqualBool Atom a
old Atom a
new))
  {-# INLINE casBoolMutableByteArray# #-}
  casBoolOffAddr# :: Addr#
-> Int# -> Atom a -> Atom a -> State# s -> (# State# s, Bool #)
casBoolOffAddr# Addr#
addr# Int#
i# Atom a
old Atom a
new =
    Addr#
-> Int#
-> (Atom a -> (# Atom a, Bool #))
-> State# s
-> (# State# s, Bool #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (Atom a -> Atom a -> Atom a -> (# Atom a, Bool #)
forall e. Eq e => Atom e -> Atom e -> Atom e -> (# Atom e, Bool #)
swapIfEqualBool Atom a
old Atom a
new)
  {-# INLINE casBoolOffAddr# #-}
  atomicModifyMutableByteArray# :: MutableByteArray# s
-> Int#
-> (Atom a -> (# Atom a, b #))
-> State# s
-> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# Atom a -> (# Atom a, b #)
f =
    ST s b -> State# s -> (# State# s, b #)
forall s a. ST s a -> State# s -> (# State# s, a #)
unST (MutableByteArray# s
-> Int# -> (Atom a -> (# Atom a, b #)) -> ST s b
forall e a (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
MutableByteArray# s -> Int# -> (Atom e -> (# Atom e, a #)) -> m a
atomicModifyAtomMutableByteArray MutableByteArray# s
mba# Int#
i# Atom a -> (# Atom a, b #)
f)
  {-# INLINE atomicModifyMutableByteArray#  #-}
  atomicModifyOffAddr# :: Addr#
-> Int#
-> (Atom a -> (# Atom a, b #))
-> State# s
-> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# Atom a -> (# Atom a, b #)
f = ST s b -> State# s -> (# State# s, b #)
forall s a. ST s a -> State# s -> (# State# s, a #)
unST (Addr# -> Int# -> (Atom a -> (# Atom a, b #)) -> ST s b
forall e a (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Addr# -> Int# -> (Atom e -> (# Atom e, a #)) -> m a
atomicModifyAtomOffAddr Addr#
addr# Int#
i# Atom a -> (# Atom a, b #)
f)
  {-# INLINE atomicModifyOffAddr#  #-}



atomicAddFetchOldMutableByteArrayNum#
  , atomicAddFetchNewMutableByteArrayNum#
  , atomicSubFetchOldMutableByteArrayNum#
  , atomicSubFetchNewMutableByteArrayNum# ::
     (Num a, Atomic a)
  => MutableByteArray# s
  -> Int#
  -> a
  -> State# s
  -> (# State# s, a #)
atomicAddFetchOldMutableByteArrayNum# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchOldMutableByteArrayNum# MutableByteArray# s
mba# Int#
i# a
y =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
x -> (# a
x a -> a -> a
forall a. Num a => a -> a -> a
+ a
y, a
x #))
{-# INLINE atomicAddFetchOldMutableByteArrayNum# #-}

atomicAddFetchNewMutableByteArrayNum# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchNewMutableByteArrayNum# MutableByteArray# s
mba# Int#
i# a
y =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
x -> let x' :: a
x' = a
x a -> a -> a
forall a. Num a => a -> a -> a
+ a
y in (# a
x', a
x' #))
{-# INLINE atomicAddFetchNewMutableByteArrayNum# #-}

atomicSubFetchOldMutableByteArrayNum# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchOldMutableByteArrayNum# MutableByteArray# s
mba# Int#
i# a
y =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
x -> (# a
x a -> a -> a
forall a. Num a => a -> a -> a
- a
y, a
x #))
{-# INLINE atomicSubFetchOldMutableByteArrayNum# #-}

atomicSubFetchNewMutableByteArrayNum# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchNewMutableByteArrayNum# MutableByteArray# s
mba# Int#
i# a
y =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
x -> let x' :: a
x' = a
x a -> a -> a
forall a. Num a => a -> a -> a
- a
y in (# a
x', a
x' #))
{-# INLINE atomicSubFetchNewMutableByteArrayNum# #-}

atomicAddFetchOldOffAddrNum#
  , atomicAddFetchNewOffAddrNum#
  , atomicSubFetchOldOffAddrNum#
  , atomicSubFetchNewOffAddrNum# ::
     (Num a, Atomic a)
  => Addr#
  -> Int#
  -> a
  -> State# s
  -> (# State# s, a #)
atomicAddFetchOldOffAddrNum# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchOldOffAddrNum# Addr#
addr# Int#
i# a
y =
  Addr# -> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
x -> (# a
x a -> a -> a
forall a. Num a => a -> a -> a
+ a
y, a
x #))
{-# INLINE atomicAddFetchOldOffAddrNum# #-}
atomicAddFetchNewOffAddrNum# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchNewOffAddrNum# Addr#
addr# Int#
i# a
y =
  Addr# -> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
x -> let x' :: a
x' = a
x a -> a -> a
forall a. Num a => a -> a -> a
+ a
y in (# a
x', a
x' #))
{-# INLINE atomicAddFetchNewOffAddrNum# #-}
atomicSubFetchOldOffAddrNum# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchOldOffAddrNum# Addr#
addr# Int#
i# a
y =
  Addr# -> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
x -> (# a
x a -> a -> a
forall a. Num a => a -> a -> a
- a
y, a
x #))
{-# INLINE atomicSubFetchOldOffAddrNum# #-}
atomicSubFetchNewOffAddrNum# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchNewOffAddrNum# Addr#
addr# Int#
i# a
y =
  Addr# -> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
x -> let x' :: a
x' = a
x a -> a -> a
forall a. Num a => a -> a -> a
- a
y in (# a
x', a
x' #))
{-# INLINE atomicSubFetchNewOffAddrNum# #-}


instance (Num a, Eq a, Prim a) => AtomicCount (Atom a) where
  atomicAddFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicAddFetchOldMutableByteArray# = MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Num a, Atomic a) =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchOldMutableByteArrayNum#
  {-# INLINE atomicAddFetchOldMutableByteArray# #-}
  atomicAddFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicAddFetchNewMutableByteArray# = MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Num a, Atomic a) =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchNewMutableByteArrayNum#
  {-# INLINE atomicAddFetchNewMutableByteArray# #-}
  atomicSubFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicSubFetchOldMutableByteArray# = MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Num a, Atomic a) =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchOldMutableByteArrayNum#
  {-# INLINE atomicSubFetchOldMutableByteArray# #-}
  atomicSubFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicSubFetchNewMutableByteArray# = MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Num a, Atomic a) =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchNewMutableByteArrayNum#
  {-# INLINE atomicSubFetchNewMutableByteArray# #-}
  atomicAddFetchOldOffAddr# :: Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicAddFetchOldOffAddr# = Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Num a, Atomic a) =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchOldOffAddrNum#
  {-# INLINE atomicAddFetchOldOffAddr# #-}
  atomicAddFetchNewOffAddr# :: Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicAddFetchNewOffAddr# = Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Num a, Atomic a) =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAddFetchNewOffAddrNum#
  {-# INLINE atomicAddFetchNewOffAddr# #-}
  atomicSubFetchOldOffAddr# :: Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicSubFetchOldOffAddr# = Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Num a, Atomic a) =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchOldOffAddrNum#
  {-# INLINE atomicSubFetchOldOffAddr# #-}
  atomicSubFetchNewOffAddr# :: Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicSubFetchNewOffAddr# = Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Num a, Atomic a) =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicSubFetchNewOffAddrNum#
  {-# INLINE atomicSubFetchNewOffAddr# #-}

atomicAndFetchOldMutableByteArrayBits#
  , atomicAndFetchNewMutableByteArrayBits#
  , atomicNandFetchOldMutableByteArrayBits#
  , atomicNandFetchNewMutableByteArrayBits#
  , atomicOrFetchOldMutableByteArrayBits#
  , atomicOrFetchNewMutableByteArrayBits#
  , atomicXorFetchOldMutableByteArrayBits#
  , atomicXorFetchNewMutableByteArrayBits# ::
     (Bits a, Atomic a)
  => MutableByteArray# s
  -> Int#
  -> a
  -> State# s
  -> (# State# s, a #)
atomicAndFetchOldMutableByteArrayBits# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchOldMutableByteArrayBits# MutableByteArray# s
mba# Int#
i# a
y =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
x -> (# a
x a -> a -> a
forall a. Bits a => a -> a -> a
.&. a
y, a
x #))
{-# INLINE atomicAndFetchOldMutableByteArrayBits# #-}
atomicAndFetchNewMutableByteArrayBits# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchNewMutableByteArrayBits# MutableByteArray# s
mba# Int#
i# a
y =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
x -> let x' :: a
x' = a
x a -> a -> a
forall a. Bits a => a -> a -> a
.&. a
y in (# a
x', a
x' #))
{-# INLINE atomicAndFetchNewMutableByteArrayBits# #-}
atomicNandFetchOldMutableByteArrayBits# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchOldMutableByteArrayBits# MutableByteArray# s
mba# Int#
i# a
y =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
x -> (# a -> a
forall a. Bits a => a -> a
complement (a
x a -> a -> a
forall a. Bits a => a -> a -> a
.&. a
y), a
x #))
{-# INLINE atomicNandFetchOldMutableByteArrayBits# #-}
atomicNandFetchNewMutableByteArrayBits# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchNewMutableByteArrayBits# MutableByteArray# s
mba# Int#
i# a
y =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
x -> let x' :: a
x' = a -> a
forall a. Bits a => a -> a
complement (a
x a -> a -> a
forall a. Bits a => a -> a -> a
.&. a
y) in (# a
x', a
x' #))
{-# INLINE atomicNandFetchNewMutableByteArrayBits# #-}
atomicOrFetchOldMutableByteArrayBits# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchOldMutableByteArrayBits# MutableByteArray# s
mba# Int#
i# a
y =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
x -> (# a
x a -> a -> a
forall a. Bits a => a -> a -> a
.|. a
y, a
x #))
{-# INLINE atomicOrFetchOldMutableByteArrayBits# #-}
atomicOrFetchNewMutableByteArrayBits# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchNewMutableByteArrayBits# MutableByteArray# s
mba# Int#
i# a
y =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
x -> let x' :: a
x' = a
x a -> a -> a
forall a. Bits a => a -> a -> a
.|. a
y in (# a
x', a
x' #))
{-# INLINE atomicOrFetchNewMutableByteArrayBits# #-}
atomicXorFetchOldMutableByteArrayBits# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchOldMutableByteArrayBits# MutableByteArray# s
mba# Int#
i# a
y =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
x -> (# a
x a -> a -> a
forall a. Bits a => a -> a -> a
`xor` a
y, a
x #))
{-# INLINE atomicXorFetchOldMutableByteArrayBits# #-}
atomicXorFetchNewMutableByteArrayBits# :: MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchNewMutableByteArrayBits# MutableByteArray# s
mba# Int#
i# a
y =
  MutableByteArray# s
-> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a s b.
Atomic a =>
MutableByteArray# s
-> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyMutableByteArray# MutableByteArray# s
mba# Int#
i# (\a
x -> let x' :: a
x' = a
x a -> a -> a
forall a. Bits a => a -> a -> a
`xor` a
y in (# a
x', a
x' #))
{-# INLINE atomicXorFetchNewMutableByteArrayBits# #-}

atomicAndFetchOldOffAddrBits#
  , atomicAndFetchNewOffAddrBits#
  , atomicNandFetchOldOffAddrBits#
  , atomicNandFetchNewOffAddrBits#
  , atomicOrFetchOldOffAddrBits#
  , atomicOrFetchNewOffAddrBits#
  , atomicXorFetchOldOffAddrBits#
  , atomicXorFetchNewOffAddrBits# ::
     (Bits a, Atomic a)
  => Addr#
  -> Int#
  -> a
  -> State# s
  -> (# State# s, a #)
atomicAndFetchOldOffAddrBits# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchOldOffAddrBits# Addr#
addr# Int#
i# a
y =
  Addr# -> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
x -> (# a
x a -> a -> a
forall a. Bits a => a -> a -> a
.&. a
y, a
x #))
{-# INLINE atomicAndFetchOldOffAddrBits# #-}
atomicAndFetchNewOffAddrBits# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchNewOffAddrBits# Addr#
addr# Int#
i# a
y =
  Addr# -> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
x -> let x' :: a
x' = a
x a -> a -> a
forall a. Bits a => a -> a -> a
.&. a
y in (# a
x', a
x' #))
{-# INLINE atomicAndFetchNewOffAddrBits# #-}
atomicNandFetchOldOffAddrBits# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchOldOffAddrBits# Addr#
addr# Int#
i# a
y =
  Addr# -> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
x -> (# a -> a
forall a. Bits a => a -> a
complement (a
x a -> a -> a
forall a. Bits a => a -> a -> a
.&. a
y), a
x #))
{-# INLINE atomicNandFetchOldOffAddrBits# #-}
atomicNandFetchNewOffAddrBits# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchNewOffAddrBits# Addr#
addr# Int#
i# a
y =
  Addr# -> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
x -> let x' :: a
x' = a -> a
forall a. Bits a => a -> a
complement (a
x a -> a -> a
forall a. Bits a => a -> a -> a
.&. a
y) in (# a
x', a
x' #))
{-# INLINE atomicNandFetchNewOffAddrBits# #-}
atomicOrFetchOldOffAddrBits# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchOldOffAddrBits# Addr#
addr# Int#
i# a
y =
  Addr# -> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
x -> (# a
x a -> a -> a
forall a. Bits a => a -> a -> a
.|. a
y, a
x #))
{-# INLINE atomicOrFetchOldOffAddrBits# #-}
atomicOrFetchNewOffAddrBits# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchNewOffAddrBits# Addr#
addr# Int#
i# a
y =
  Addr# -> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
x -> let x' :: a
x' = a
x a -> a -> a
forall a. Bits a => a -> a -> a
.|. a
y in (# a
x', a
x' #))
{-# INLINE atomicOrFetchNewOffAddrBits# #-}
atomicXorFetchOldOffAddrBits# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchOldOffAddrBits# Addr#
addr# Int#
i# a
y =
  Addr# -> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
x -> (# a
x a -> a -> a
forall a. Bits a => a -> a -> a
`xor` a
y, a
x #))
{-# INLINE atomicXorFetchOldOffAddrBits# #-}
atomicXorFetchNewOffAddrBits# :: Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchNewOffAddrBits# Addr#
addr# Int#
i# a
y =
  Addr# -> Int# -> (a -> (# a, a #)) -> State# s -> (# State# s, a #)
forall a b s.
Atomic a =>
Addr# -> Int# -> (a -> (# a, b #)) -> State# s -> (# State# s, b #)
atomicModifyOffAddr# Addr#
addr# Int#
i# (\a
x -> let x' :: a
x' = a
x a -> a -> a
forall a. Bits a => a -> a -> a
`xor` a
y in (# a
x', a
x' #))
{-# INLINE atomicXorFetchNewOffAddrBits# #-}


instance (Bits a, Eq a, Prim a) => AtomicBits (Atom a) where
  atomicAndFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicAndFetchOldMutableByteArray# = MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchOldMutableByteArrayBits#
  {-# INLINE atomicAndFetchOldMutableByteArray# #-}
  atomicAndFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicAndFetchNewMutableByteArray# = MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchNewMutableByteArrayBits#
  {-# INLINE atomicAndFetchNewMutableByteArray# #-}
  atomicNandFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicNandFetchOldMutableByteArray# = MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchOldMutableByteArrayBits#
  {-# INLINE atomicNandFetchOldMutableByteArray# #-}
  atomicNandFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicNandFetchNewMutableByteArray# = MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchNewMutableByteArrayBits#
  {-# INLINE atomicNandFetchNewMutableByteArray# #-}
  atomicOrFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicOrFetchOldMutableByteArray# = MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchOldMutableByteArrayBits#
  {-# INLINE atomicOrFetchOldMutableByteArray# #-}
  atomicOrFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicOrFetchNewMutableByteArray# = MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchNewMutableByteArrayBits#
  {-# INLINE atomicOrFetchNewMutableByteArray# #-}
  atomicXorFetchOldMutableByteArray# :: MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicXorFetchOldMutableByteArray# = MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchOldMutableByteArrayBits#
  {-# INLINE atomicXorFetchOldMutableByteArray# #-}
  atomicXorFetchNewMutableByteArray# :: MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicXorFetchNewMutableByteArray# = MutableByteArray# s
-> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
MutableByteArray# s -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchNewMutableByteArrayBits#
  {-# INLINE atomicXorFetchNewMutableByteArray# #-}
  atomicAndFetchOldOffAddr# :: Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicAndFetchOldOffAddr# = Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchOldOffAddrBits#
  {-# INLINE atomicAndFetchOldOffAddr# #-}
  atomicAndFetchNewOffAddr# :: Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicAndFetchNewOffAddr# = Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicAndFetchNewOffAddrBits#
  {-# INLINE atomicAndFetchNewOffAddr# #-}
  atomicNandFetchOldOffAddr# :: Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicNandFetchOldOffAddr# = Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchOldOffAddrBits#
  {-# INLINE atomicNandFetchOldOffAddr# #-}
  atomicNandFetchNewOffAddr# :: Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicNandFetchNewOffAddr# = Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicNandFetchNewOffAddrBits#
  {-# INLINE atomicNandFetchNewOffAddr# #-}
  atomicOrFetchOldOffAddr# :: Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicOrFetchOldOffAddr# = Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchOldOffAddrBits#
  {-# INLINE atomicOrFetchOldOffAddr# #-}
  atomicOrFetchNewOffAddr# :: Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicOrFetchNewOffAddr# = Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicOrFetchNewOffAddrBits#
  {-# INLINE atomicOrFetchNewOffAddr# #-}
  atomicXorFetchOldOffAddr# :: Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicXorFetchOldOffAddr# = Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchOldOffAddrBits#
  {-# INLINE atomicXorFetchOldOffAddr# #-}
  atomicXorFetchNewOffAddr# :: Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
atomicXorFetchNewOffAddr# = Addr# -> Int# -> Atom a -> State# s -> (# State# s, Atom a #)
forall a s.
(Bits a, Atomic a) =>
Addr# -> Int# -> a -> State# s -> (# State# s, a #)
atomicXorFetchNewOffAddrBits#
  {-# INLINE atomicXorFetchNewOffAddr# #-}