{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE UndecidableInstances #-}
module Data.Prim.Atom
( Atom(..)
, acquireLockByteOffMutableByteArray
, releaseLockByteOffMutableByteArray
, acquireLockByteOffAddr
, releaseLockByteOffAddr
, withLockMutableByteArray
, withLockOffAddr
, atomicAddFetchOldMutableByteArrayNum#
, atomicAddFetchNewMutableByteArrayNum#
, atomicSubFetchOldMutableByteArrayNum#
, atomicSubFetchNewMutableByteArrayNum#
, atomicAddFetchOldOffAddrNum#
, atomicAddFetchNewOffAddrNum#
, atomicSubFetchOldOffAddrNum#
, atomicSubFetchNewOffAddrNum#
, 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 #-}
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 #-}
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 #-}
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 #-}
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# #-}