{-# LANGUAGE DataKinds                  #-}
{-# LANGUAGE DeriveDataTypeable         #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE Strict                     #-}
module Graphics.Vulkan.Types.BaseTypes
       (VkBool32(..), VkDeviceSize(..), VkFlags(..), VkSampleMask(..))
       where
import           Data.Bits               (Bits, FiniteBits)
import           Data.Coerce             (coerce)
import           Data.Data               (Data)
import           Foreign.Storable        (Storable)
import           GHC.Generics            (Generic)
import           Graphics.Vulkan.Marshal (Word32, Word64)

newtype VkBool32 = VkBool32 Word32
                     deriving (VkBool32 -> VkBool32 -> Bool
(VkBool32 -> VkBool32 -> Bool)
-> (VkBool32 -> VkBool32 -> Bool) -> Eq VkBool32
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkBool32 -> VkBool32 -> Bool
$c/= :: VkBool32 -> VkBool32 -> Bool
== :: VkBool32 -> VkBool32 -> Bool
$c== :: VkBool32 -> VkBool32 -> Bool
Eq, Eq VkBool32
Eq VkBool32
-> (VkBool32 -> VkBool32 -> Ordering)
-> (VkBool32 -> VkBool32 -> Bool)
-> (VkBool32 -> VkBool32 -> Bool)
-> (VkBool32 -> VkBool32 -> Bool)
-> (VkBool32 -> VkBool32 -> Bool)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> Ord VkBool32
VkBool32 -> VkBool32 -> Bool
VkBool32 -> VkBool32 -> Ordering
VkBool32 -> VkBool32 -> VkBool32
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
min :: VkBool32 -> VkBool32 -> VkBool32
$cmin :: VkBool32 -> VkBool32 -> VkBool32
max :: VkBool32 -> VkBool32 -> VkBool32
$cmax :: VkBool32 -> VkBool32 -> VkBool32
>= :: VkBool32 -> VkBool32 -> Bool
$c>= :: VkBool32 -> VkBool32 -> Bool
> :: VkBool32 -> VkBool32 -> Bool
$c> :: VkBool32 -> VkBool32 -> Bool
<= :: VkBool32 -> VkBool32 -> Bool
$c<= :: VkBool32 -> VkBool32 -> Bool
< :: VkBool32 -> VkBool32 -> Bool
$c< :: VkBool32 -> VkBool32 -> Bool
compare :: VkBool32 -> VkBool32 -> Ordering
$ccompare :: VkBool32 -> VkBool32 -> Ordering
$cp1Ord :: Eq VkBool32
Ord, Integer -> VkBool32
VkBool32 -> VkBool32
VkBool32 -> VkBool32 -> VkBool32
(VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32)
-> (Integer -> VkBool32)
-> Num VkBool32
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> VkBool32
$cfromInteger :: Integer -> VkBool32
signum :: VkBool32 -> VkBool32
$csignum :: VkBool32 -> VkBool32
abs :: VkBool32 -> VkBool32
$cabs :: VkBool32 -> VkBool32
negate :: VkBool32 -> VkBool32
$cnegate :: VkBool32 -> VkBool32
* :: VkBool32 -> VkBool32 -> VkBool32
$c* :: VkBool32 -> VkBool32 -> VkBool32
- :: VkBool32 -> VkBool32 -> VkBool32
$c- :: VkBool32 -> VkBool32 -> VkBool32
+ :: VkBool32 -> VkBool32 -> VkBool32
$c+ :: VkBool32 -> VkBool32 -> VkBool32
Num, VkBool32
VkBool32 -> VkBool32 -> Bounded VkBool32
forall a. a -> a -> Bounded a
maxBound :: VkBool32
$cmaxBound :: VkBool32
minBound :: VkBool32
$cminBound :: VkBool32
Bounded, Int -> VkBool32
VkBool32 -> Int
VkBool32 -> [VkBool32]
VkBool32 -> VkBool32
VkBool32 -> VkBool32 -> [VkBool32]
VkBool32 -> VkBool32 -> VkBool32 -> [VkBool32]
(VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32)
-> (Int -> VkBool32)
-> (VkBool32 -> Int)
-> (VkBool32 -> [VkBool32])
-> (VkBool32 -> VkBool32 -> [VkBool32])
-> (VkBool32 -> VkBool32 -> [VkBool32])
-> (VkBool32 -> VkBool32 -> VkBool32 -> [VkBool32])
-> Enum VkBool32
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 :: VkBool32 -> VkBool32 -> VkBool32 -> [VkBool32]
$cenumFromThenTo :: VkBool32 -> VkBool32 -> VkBool32 -> [VkBool32]
enumFromTo :: VkBool32 -> VkBool32 -> [VkBool32]
$cenumFromTo :: VkBool32 -> VkBool32 -> [VkBool32]
enumFromThen :: VkBool32 -> VkBool32 -> [VkBool32]
$cenumFromThen :: VkBool32 -> VkBool32 -> [VkBool32]
enumFrom :: VkBool32 -> [VkBool32]
$cenumFrom :: VkBool32 -> [VkBool32]
fromEnum :: VkBool32 -> Int
$cfromEnum :: VkBool32 -> Int
toEnum :: Int -> VkBool32
$ctoEnum :: Int -> VkBool32
pred :: VkBool32 -> VkBool32
$cpred :: VkBool32 -> VkBool32
succ :: VkBool32 -> VkBool32
$csucc :: VkBool32 -> VkBool32
Enum, Enum VkBool32
Real VkBool32
Real VkBool32
-> Enum VkBool32
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> (VkBool32, VkBool32))
-> (VkBool32 -> VkBool32 -> (VkBool32, VkBool32))
-> (VkBool32 -> Integer)
-> Integral VkBool32
VkBool32 -> Integer
VkBool32 -> VkBool32 -> (VkBool32, VkBool32)
VkBool32 -> VkBool32 -> VkBool32
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 :: VkBool32 -> Integer
$ctoInteger :: VkBool32 -> Integer
divMod :: VkBool32 -> VkBool32 -> (VkBool32, VkBool32)
$cdivMod :: VkBool32 -> VkBool32 -> (VkBool32, VkBool32)
quotRem :: VkBool32 -> VkBool32 -> (VkBool32, VkBool32)
$cquotRem :: VkBool32 -> VkBool32 -> (VkBool32, VkBool32)
mod :: VkBool32 -> VkBool32 -> VkBool32
$cmod :: VkBool32 -> VkBool32 -> VkBool32
div :: VkBool32 -> VkBool32 -> VkBool32
$cdiv :: VkBool32 -> VkBool32 -> VkBool32
rem :: VkBool32 -> VkBool32 -> VkBool32
$crem :: VkBool32 -> VkBool32 -> VkBool32
quot :: VkBool32 -> VkBool32 -> VkBool32
$cquot :: VkBool32 -> VkBool32 -> VkBool32
$cp2Integral :: Enum VkBool32
$cp1Integral :: Real VkBool32
Integral, Eq VkBool32
VkBool32
Eq VkBool32
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32 -> VkBool32)
-> (VkBool32 -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> VkBool32
-> (Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> Bool)
-> (VkBool32 -> Maybe Int)
-> (VkBool32 -> Int)
-> (VkBool32 -> Bool)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int -> VkBool32)
-> (VkBool32 -> Int)
-> Bits VkBool32
Int -> VkBool32
VkBool32 -> Bool
VkBool32 -> Int
VkBool32 -> Maybe Int
VkBool32 -> VkBool32
VkBool32 -> Int -> Bool
VkBool32 -> Int -> VkBool32
VkBool32 -> VkBool32 -> VkBool32
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
popCount :: VkBool32 -> Int
$cpopCount :: VkBool32 -> Int
rotateR :: VkBool32 -> Int -> VkBool32
$crotateR :: VkBool32 -> Int -> VkBool32
rotateL :: VkBool32 -> Int -> VkBool32
$crotateL :: VkBool32 -> Int -> VkBool32
unsafeShiftR :: VkBool32 -> Int -> VkBool32
$cunsafeShiftR :: VkBool32 -> Int -> VkBool32
shiftR :: VkBool32 -> Int -> VkBool32
$cshiftR :: VkBool32 -> Int -> VkBool32
unsafeShiftL :: VkBool32 -> Int -> VkBool32
$cunsafeShiftL :: VkBool32 -> Int -> VkBool32
shiftL :: VkBool32 -> Int -> VkBool32
$cshiftL :: VkBool32 -> Int -> VkBool32
isSigned :: VkBool32 -> Bool
$cisSigned :: VkBool32 -> Bool
bitSize :: VkBool32 -> Int
$cbitSize :: VkBool32 -> Int
bitSizeMaybe :: VkBool32 -> Maybe Int
$cbitSizeMaybe :: VkBool32 -> Maybe Int
testBit :: VkBool32 -> Int -> Bool
$ctestBit :: VkBool32 -> Int -> Bool
complementBit :: VkBool32 -> Int -> VkBool32
$ccomplementBit :: VkBool32 -> Int -> VkBool32
clearBit :: VkBool32 -> Int -> VkBool32
$cclearBit :: VkBool32 -> Int -> VkBool32
setBit :: VkBool32 -> Int -> VkBool32
$csetBit :: VkBool32 -> Int -> VkBool32
bit :: Int -> VkBool32
$cbit :: Int -> VkBool32
zeroBits :: VkBool32
$czeroBits :: VkBool32
rotate :: VkBool32 -> Int -> VkBool32
$crotate :: VkBool32 -> Int -> VkBool32
shift :: VkBool32 -> Int -> VkBool32
$cshift :: VkBool32 -> Int -> VkBool32
complement :: VkBool32 -> VkBool32
$ccomplement :: VkBool32 -> VkBool32
xor :: VkBool32 -> VkBool32 -> VkBool32
$cxor :: VkBool32 -> VkBool32 -> VkBool32
.|. :: VkBool32 -> VkBool32 -> VkBool32
$c.|. :: VkBool32 -> VkBool32 -> VkBool32
.&. :: VkBool32 -> VkBool32 -> VkBool32
$c.&. :: VkBool32 -> VkBool32 -> VkBool32
$cp1Bits :: Eq VkBool32
Bits, Bits VkBool32
Bits VkBool32
-> (VkBool32 -> Int)
-> (VkBool32 -> Int)
-> (VkBool32 -> Int)
-> FiniteBits VkBool32
VkBool32 -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkBool32 -> Int
$ccountTrailingZeros :: VkBool32 -> Int
countLeadingZeros :: VkBool32 -> Int
$ccountLeadingZeros :: VkBool32 -> Int
finiteBitSize :: VkBool32 -> Int
$cfiniteBitSize :: VkBool32 -> Int
$cp1FiniteBits :: Bits VkBool32
FiniteBits,
                               Ptr b -> Int -> IO VkBool32
Ptr b -> Int -> VkBool32 -> IO ()
Ptr VkBool32 -> IO VkBool32
Ptr VkBool32 -> Int -> IO VkBool32
Ptr VkBool32 -> Int -> VkBool32 -> IO ()
Ptr VkBool32 -> VkBool32 -> IO ()
VkBool32 -> Int
(VkBool32 -> Int)
-> (VkBool32 -> Int)
-> (Ptr VkBool32 -> Int -> IO VkBool32)
-> (Ptr VkBool32 -> Int -> VkBool32 -> IO ())
-> (forall b. Ptr b -> Int -> IO VkBool32)
-> (forall b. Ptr b -> Int -> VkBool32 -> IO ())
-> (Ptr VkBool32 -> IO VkBool32)
-> (Ptr VkBool32 -> VkBool32 -> IO ())
-> Storable VkBool32
forall b. Ptr b -> Int -> IO VkBool32
forall b. Ptr b -> Int -> VkBool32 -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkBool32 -> VkBool32 -> IO ()
$cpoke :: Ptr VkBool32 -> VkBool32 -> IO ()
peek :: Ptr VkBool32 -> IO VkBool32
$cpeek :: Ptr VkBool32 -> IO VkBool32
pokeByteOff :: Ptr b -> Int -> VkBool32 -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkBool32 -> IO ()
peekByteOff :: Ptr b -> Int -> IO VkBool32
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkBool32
pokeElemOff :: Ptr VkBool32 -> Int -> VkBool32 -> IO ()
$cpokeElemOff :: Ptr VkBool32 -> Int -> VkBool32 -> IO ()
peekElemOff :: Ptr VkBool32 -> Int -> IO VkBool32
$cpeekElemOff :: Ptr VkBool32 -> Int -> IO VkBool32
alignment :: VkBool32 -> Int
$calignment :: VkBool32 -> Int
sizeOf :: VkBool32 -> Int
$csizeOf :: VkBool32 -> Int
Storable, Num VkBool32
Ord VkBool32
Num VkBool32
-> Ord VkBool32 -> (VkBool32 -> Rational) -> Real VkBool32
VkBool32 -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: VkBool32 -> Rational
$ctoRational :: VkBool32 -> Rational
$cp2Real :: Ord VkBool32
$cp1Real :: Num VkBool32
Real, Typeable VkBool32
DataType
Constr
Typeable VkBool32
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VkBool32 -> c VkBool32)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c VkBool32)
-> (VkBool32 -> Constr)
-> (VkBool32 -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c VkBool32))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkBool32))
-> ((forall b. Data b => b -> b) -> VkBool32 -> VkBool32)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VkBool32 -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VkBool32 -> r)
-> (forall u. (forall d. Data d => d -> u) -> VkBool32 -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> VkBool32 -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> VkBool32 -> m VkBool32)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VkBool32 -> m VkBool32)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VkBool32 -> m VkBool32)
-> Data VkBool32
VkBool32 -> DataType
VkBool32 -> Constr
(forall b. Data b => b -> b) -> VkBool32 -> VkBool32
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkBool32 -> c VkBool32
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkBool32
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> VkBool32 -> u
forall u. (forall d. Data d => d -> u) -> VkBool32 -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkBool32 -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkBool32 -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VkBool32 -> m VkBool32
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VkBool32 -> m VkBool32
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkBool32
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkBool32 -> c VkBool32
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VkBool32)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkBool32)
$cVkBool32 :: Constr
$tVkBool32 :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> VkBool32 -> m VkBool32
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VkBool32 -> m VkBool32
gmapMp :: (forall d. Data d => d -> m d) -> VkBool32 -> m VkBool32
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VkBool32 -> m VkBool32
gmapM :: (forall d. Data d => d -> m d) -> VkBool32 -> m VkBool32
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VkBool32 -> m VkBool32
gmapQi :: Int -> (forall d. Data d => d -> u) -> VkBool32 -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VkBool32 -> u
gmapQ :: (forall d. Data d => d -> u) -> VkBool32 -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VkBool32 -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkBool32 -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkBool32 -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkBool32 -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkBool32 -> r
gmapT :: (forall b. Data b => b -> b) -> VkBool32 -> VkBool32
$cgmapT :: (forall b. Data b => b -> b) -> VkBool32 -> VkBool32
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkBool32)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkBool32)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c VkBool32)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VkBool32)
dataTypeOf :: VkBool32 -> DataType
$cdataTypeOf :: VkBool32 -> DataType
toConstr :: VkBool32 -> Constr
$ctoConstr :: VkBool32 -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkBool32
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkBool32
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkBool32 -> c VkBool32
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkBool32 -> c VkBool32
$cp1Data :: Typeable VkBool32
Data, (forall x. VkBool32 -> Rep VkBool32 x)
-> (forall x. Rep VkBool32 x -> VkBool32) -> Generic VkBool32
forall x. Rep VkBool32 x -> VkBool32
forall x. VkBool32 -> Rep VkBool32 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VkBool32 x -> VkBool32
$cfrom :: forall x. VkBool32 -> Rep VkBool32 x
Generic)

instance Show VkBool32 where
        {-# INLINE show #-}
        show :: VkBool32 -> String
show (VkBool32 Word32
x) = Word32 -> String
forall a. Show a => a -> String
show Word32
x

instance Read VkBool32 where
        {-# INLINE readsPrec #-}
        readsPrec :: Int -> ReadS VkBool32
readsPrec = (Int -> ReadS Word32) -> Int -> ReadS VkBool32
coerce (Int -> ReadS Word32
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS Word32)

newtype VkDeviceSize = VkDeviceSize Word64
                         deriving (VkDeviceSize -> VkDeviceSize -> Bool
(VkDeviceSize -> VkDeviceSize -> Bool)
-> (VkDeviceSize -> VkDeviceSize -> Bool) -> Eq VkDeviceSize
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkDeviceSize -> VkDeviceSize -> Bool
$c/= :: VkDeviceSize -> VkDeviceSize -> Bool
== :: VkDeviceSize -> VkDeviceSize -> Bool
$c== :: VkDeviceSize -> VkDeviceSize -> Bool
Eq, Eq VkDeviceSize
Eq VkDeviceSize
-> (VkDeviceSize -> VkDeviceSize -> Ordering)
-> (VkDeviceSize -> VkDeviceSize -> Bool)
-> (VkDeviceSize -> VkDeviceSize -> Bool)
-> (VkDeviceSize -> VkDeviceSize -> Bool)
-> (VkDeviceSize -> VkDeviceSize -> Bool)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> Ord VkDeviceSize
VkDeviceSize -> VkDeviceSize -> Bool
VkDeviceSize -> VkDeviceSize -> Ordering
VkDeviceSize -> VkDeviceSize -> VkDeviceSize
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
min :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$cmin :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
max :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$cmax :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
>= :: VkDeviceSize -> VkDeviceSize -> Bool
$c>= :: VkDeviceSize -> VkDeviceSize -> Bool
> :: VkDeviceSize -> VkDeviceSize -> Bool
$c> :: VkDeviceSize -> VkDeviceSize -> Bool
<= :: VkDeviceSize -> VkDeviceSize -> Bool
$c<= :: VkDeviceSize -> VkDeviceSize -> Bool
< :: VkDeviceSize -> VkDeviceSize -> Bool
$c< :: VkDeviceSize -> VkDeviceSize -> Bool
compare :: VkDeviceSize -> VkDeviceSize -> Ordering
$ccompare :: VkDeviceSize -> VkDeviceSize -> Ordering
$cp1Ord :: Eq VkDeviceSize
Ord, Integer -> VkDeviceSize
VkDeviceSize -> VkDeviceSize
VkDeviceSize -> VkDeviceSize -> VkDeviceSize
(VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize)
-> (Integer -> VkDeviceSize)
-> Num VkDeviceSize
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> VkDeviceSize
$cfromInteger :: Integer -> VkDeviceSize
signum :: VkDeviceSize -> VkDeviceSize
$csignum :: VkDeviceSize -> VkDeviceSize
abs :: VkDeviceSize -> VkDeviceSize
$cabs :: VkDeviceSize -> VkDeviceSize
negate :: VkDeviceSize -> VkDeviceSize
$cnegate :: VkDeviceSize -> VkDeviceSize
* :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$c* :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
- :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$c- :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
+ :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$c+ :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
Num, VkDeviceSize
VkDeviceSize -> VkDeviceSize -> Bounded VkDeviceSize
forall a. a -> a -> Bounded a
maxBound :: VkDeviceSize
$cmaxBound :: VkDeviceSize
minBound :: VkDeviceSize
$cminBound :: VkDeviceSize
Bounded, Int -> VkDeviceSize
VkDeviceSize -> Int
VkDeviceSize -> [VkDeviceSize]
VkDeviceSize -> VkDeviceSize
VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
VkDeviceSize -> VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
(VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize)
-> (Int -> VkDeviceSize)
-> (VkDeviceSize -> Int)
-> (VkDeviceSize -> [VkDeviceSize])
-> (VkDeviceSize -> VkDeviceSize -> [VkDeviceSize])
-> (VkDeviceSize -> VkDeviceSize -> [VkDeviceSize])
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize -> [VkDeviceSize])
-> Enum VkDeviceSize
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 :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
$cenumFromThenTo :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
enumFromTo :: VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
$cenumFromTo :: VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
enumFromThen :: VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
$cenumFromThen :: VkDeviceSize -> VkDeviceSize -> [VkDeviceSize]
enumFrom :: VkDeviceSize -> [VkDeviceSize]
$cenumFrom :: VkDeviceSize -> [VkDeviceSize]
fromEnum :: VkDeviceSize -> Int
$cfromEnum :: VkDeviceSize -> Int
toEnum :: Int -> VkDeviceSize
$ctoEnum :: Int -> VkDeviceSize
pred :: VkDeviceSize -> VkDeviceSize
$cpred :: VkDeviceSize -> VkDeviceSize
succ :: VkDeviceSize -> VkDeviceSize
$csucc :: VkDeviceSize -> VkDeviceSize
Enum, Enum VkDeviceSize
Real VkDeviceSize
Real VkDeviceSize
-> Enum VkDeviceSize
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize))
-> (VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize))
-> (VkDeviceSize -> Integer)
-> Integral VkDeviceSize
VkDeviceSize -> Integer
VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize)
VkDeviceSize -> VkDeviceSize -> VkDeviceSize
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 :: VkDeviceSize -> Integer
$ctoInteger :: VkDeviceSize -> Integer
divMod :: VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize)
$cdivMod :: VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize)
quotRem :: VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize)
$cquotRem :: VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize)
mod :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$cmod :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
div :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$cdiv :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
rem :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$crem :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
quot :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$cquot :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$cp2Integral :: Enum VkDeviceSize
$cp1Integral :: Real VkDeviceSize
Integral, Eq VkDeviceSize
VkDeviceSize
Eq VkDeviceSize
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> VkDeviceSize
-> (Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> Bool)
-> (VkDeviceSize -> Maybe Int)
-> (VkDeviceSize -> Int)
-> (VkDeviceSize -> Bool)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int -> VkDeviceSize)
-> (VkDeviceSize -> Int)
-> Bits VkDeviceSize
Int -> VkDeviceSize
VkDeviceSize -> Bool
VkDeviceSize -> Int
VkDeviceSize -> Maybe Int
VkDeviceSize -> VkDeviceSize
VkDeviceSize -> Int -> Bool
VkDeviceSize -> Int -> VkDeviceSize
VkDeviceSize -> VkDeviceSize -> VkDeviceSize
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
popCount :: VkDeviceSize -> Int
$cpopCount :: VkDeviceSize -> Int
rotateR :: VkDeviceSize -> Int -> VkDeviceSize
$crotateR :: VkDeviceSize -> Int -> VkDeviceSize
rotateL :: VkDeviceSize -> Int -> VkDeviceSize
$crotateL :: VkDeviceSize -> Int -> VkDeviceSize
unsafeShiftR :: VkDeviceSize -> Int -> VkDeviceSize
$cunsafeShiftR :: VkDeviceSize -> Int -> VkDeviceSize
shiftR :: VkDeviceSize -> Int -> VkDeviceSize
$cshiftR :: VkDeviceSize -> Int -> VkDeviceSize
unsafeShiftL :: VkDeviceSize -> Int -> VkDeviceSize
$cunsafeShiftL :: VkDeviceSize -> Int -> VkDeviceSize
shiftL :: VkDeviceSize -> Int -> VkDeviceSize
$cshiftL :: VkDeviceSize -> Int -> VkDeviceSize
isSigned :: VkDeviceSize -> Bool
$cisSigned :: VkDeviceSize -> Bool
bitSize :: VkDeviceSize -> Int
$cbitSize :: VkDeviceSize -> Int
bitSizeMaybe :: VkDeviceSize -> Maybe Int
$cbitSizeMaybe :: VkDeviceSize -> Maybe Int
testBit :: VkDeviceSize -> Int -> Bool
$ctestBit :: VkDeviceSize -> Int -> Bool
complementBit :: VkDeviceSize -> Int -> VkDeviceSize
$ccomplementBit :: VkDeviceSize -> Int -> VkDeviceSize
clearBit :: VkDeviceSize -> Int -> VkDeviceSize
$cclearBit :: VkDeviceSize -> Int -> VkDeviceSize
setBit :: VkDeviceSize -> Int -> VkDeviceSize
$csetBit :: VkDeviceSize -> Int -> VkDeviceSize
bit :: Int -> VkDeviceSize
$cbit :: Int -> VkDeviceSize
zeroBits :: VkDeviceSize
$czeroBits :: VkDeviceSize
rotate :: VkDeviceSize -> Int -> VkDeviceSize
$crotate :: VkDeviceSize -> Int -> VkDeviceSize
shift :: VkDeviceSize -> Int -> VkDeviceSize
$cshift :: VkDeviceSize -> Int -> VkDeviceSize
complement :: VkDeviceSize -> VkDeviceSize
$ccomplement :: VkDeviceSize -> VkDeviceSize
xor :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$cxor :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
.|. :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$c.|. :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
.&. :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$c.&. :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize
$cp1Bits :: Eq VkDeviceSize
Bits, Bits VkDeviceSize
Bits VkDeviceSize
-> (VkDeviceSize -> Int)
-> (VkDeviceSize -> Int)
-> (VkDeviceSize -> Int)
-> FiniteBits VkDeviceSize
VkDeviceSize -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkDeviceSize -> Int
$ccountTrailingZeros :: VkDeviceSize -> Int
countLeadingZeros :: VkDeviceSize -> Int
$ccountLeadingZeros :: VkDeviceSize -> Int
finiteBitSize :: VkDeviceSize -> Int
$cfiniteBitSize :: VkDeviceSize -> Int
$cp1FiniteBits :: Bits VkDeviceSize
FiniteBits,
                                   Ptr b -> Int -> IO VkDeviceSize
Ptr b -> Int -> VkDeviceSize -> IO ()
Ptr VkDeviceSize -> IO VkDeviceSize
Ptr VkDeviceSize -> Int -> IO VkDeviceSize
Ptr VkDeviceSize -> Int -> VkDeviceSize -> IO ()
Ptr VkDeviceSize -> VkDeviceSize -> IO ()
VkDeviceSize -> Int
(VkDeviceSize -> Int)
-> (VkDeviceSize -> Int)
-> (Ptr VkDeviceSize -> Int -> IO VkDeviceSize)
-> (Ptr VkDeviceSize -> Int -> VkDeviceSize -> IO ())
-> (forall b. Ptr b -> Int -> IO VkDeviceSize)
-> (forall b. Ptr b -> Int -> VkDeviceSize -> IO ())
-> (Ptr VkDeviceSize -> IO VkDeviceSize)
-> (Ptr VkDeviceSize -> VkDeviceSize -> IO ())
-> Storable VkDeviceSize
forall b. Ptr b -> Int -> IO VkDeviceSize
forall b. Ptr b -> Int -> VkDeviceSize -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkDeviceSize -> VkDeviceSize -> IO ()
$cpoke :: Ptr VkDeviceSize -> VkDeviceSize -> IO ()
peek :: Ptr VkDeviceSize -> IO VkDeviceSize
$cpeek :: Ptr VkDeviceSize -> IO VkDeviceSize
pokeByteOff :: Ptr b -> Int -> VkDeviceSize -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkDeviceSize -> IO ()
peekByteOff :: Ptr b -> Int -> IO VkDeviceSize
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkDeviceSize
pokeElemOff :: Ptr VkDeviceSize -> Int -> VkDeviceSize -> IO ()
$cpokeElemOff :: Ptr VkDeviceSize -> Int -> VkDeviceSize -> IO ()
peekElemOff :: Ptr VkDeviceSize -> Int -> IO VkDeviceSize
$cpeekElemOff :: Ptr VkDeviceSize -> Int -> IO VkDeviceSize
alignment :: VkDeviceSize -> Int
$calignment :: VkDeviceSize -> Int
sizeOf :: VkDeviceSize -> Int
$csizeOf :: VkDeviceSize -> Int
Storable, Num VkDeviceSize
Ord VkDeviceSize
Num VkDeviceSize
-> Ord VkDeviceSize
-> (VkDeviceSize -> Rational)
-> Real VkDeviceSize
VkDeviceSize -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: VkDeviceSize -> Rational
$ctoRational :: VkDeviceSize -> Rational
$cp2Real :: Ord VkDeviceSize
$cp1Real :: Num VkDeviceSize
Real, Typeable VkDeviceSize
DataType
Constr
Typeable VkDeviceSize
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VkDeviceSize -> c VkDeviceSize)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c VkDeviceSize)
-> (VkDeviceSize -> Constr)
-> (VkDeviceSize -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c VkDeviceSize))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c VkDeviceSize))
-> ((forall b. Data b => b -> b) -> VkDeviceSize -> VkDeviceSize)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VkDeviceSize -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VkDeviceSize -> r)
-> (forall u. (forall d. Data d => d -> u) -> VkDeviceSize -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> VkDeviceSize -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> VkDeviceSize -> m VkDeviceSize)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VkDeviceSize -> m VkDeviceSize)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VkDeviceSize -> m VkDeviceSize)
-> Data VkDeviceSize
VkDeviceSize -> DataType
VkDeviceSize -> Constr
(forall b. Data b => b -> b) -> VkDeviceSize -> VkDeviceSize
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkDeviceSize -> c VkDeviceSize
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkDeviceSize
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> VkDeviceSize -> u
forall u. (forall d. Data d => d -> u) -> VkDeviceSize -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkDeviceSize -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkDeviceSize -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VkDeviceSize -> m VkDeviceSize
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VkDeviceSize -> m VkDeviceSize
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkDeviceSize
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkDeviceSize -> c VkDeviceSize
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VkDeviceSize)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VkDeviceSize)
$cVkDeviceSize :: Constr
$tVkDeviceSize :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> VkDeviceSize -> m VkDeviceSize
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VkDeviceSize -> m VkDeviceSize
gmapMp :: (forall d. Data d => d -> m d) -> VkDeviceSize -> m VkDeviceSize
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VkDeviceSize -> m VkDeviceSize
gmapM :: (forall d. Data d => d -> m d) -> VkDeviceSize -> m VkDeviceSize
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VkDeviceSize -> m VkDeviceSize
gmapQi :: Int -> (forall d. Data d => d -> u) -> VkDeviceSize -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VkDeviceSize -> u
gmapQ :: (forall d. Data d => d -> u) -> VkDeviceSize -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VkDeviceSize -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkDeviceSize -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkDeviceSize -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkDeviceSize -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkDeviceSize -> r
gmapT :: (forall b. Data b => b -> b) -> VkDeviceSize -> VkDeviceSize
$cgmapT :: (forall b. Data b => b -> b) -> VkDeviceSize -> VkDeviceSize
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VkDeviceSize)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VkDeviceSize)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c VkDeviceSize)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VkDeviceSize)
dataTypeOf :: VkDeviceSize -> DataType
$cdataTypeOf :: VkDeviceSize -> DataType
toConstr :: VkDeviceSize -> Constr
$ctoConstr :: VkDeviceSize -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkDeviceSize
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkDeviceSize
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkDeviceSize -> c VkDeviceSize
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkDeviceSize -> c VkDeviceSize
$cp1Data :: Typeable VkDeviceSize
Data, (forall x. VkDeviceSize -> Rep VkDeviceSize x)
-> (forall x. Rep VkDeviceSize x -> VkDeviceSize)
-> Generic VkDeviceSize
forall x. Rep VkDeviceSize x -> VkDeviceSize
forall x. VkDeviceSize -> Rep VkDeviceSize x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VkDeviceSize x -> VkDeviceSize
$cfrom :: forall x. VkDeviceSize -> Rep VkDeviceSize x
Generic)

instance Show VkDeviceSize where
        {-# INLINE show #-}
        show :: VkDeviceSize -> String
show (VkDeviceSize Word64
x) = Word64 -> String
forall a. Show a => a -> String
show Word64
x

instance Read VkDeviceSize where
        {-# INLINE readsPrec #-}
        readsPrec :: Int -> ReadS VkDeviceSize
readsPrec = (Int -> ReadS Word64) -> Int -> ReadS VkDeviceSize
coerce (Int -> ReadS Word64
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS Word64)

newtype VkFlags = VkFlags Word32
                    deriving (VkFlags -> VkFlags -> Bool
(VkFlags -> VkFlags -> Bool)
-> (VkFlags -> VkFlags -> Bool) -> Eq VkFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkFlags -> VkFlags -> Bool
$c/= :: VkFlags -> VkFlags -> Bool
== :: VkFlags -> VkFlags -> Bool
$c== :: VkFlags -> VkFlags -> Bool
Eq, Eq VkFlags
Eq VkFlags
-> (VkFlags -> VkFlags -> Ordering)
-> (VkFlags -> VkFlags -> Bool)
-> (VkFlags -> VkFlags -> Bool)
-> (VkFlags -> VkFlags -> Bool)
-> (VkFlags -> VkFlags -> Bool)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> Ord VkFlags
VkFlags -> VkFlags -> Bool
VkFlags -> VkFlags -> Ordering
VkFlags -> VkFlags -> VkFlags
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
min :: VkFlags -> VkFlags -> VkFlags
$cmin :: VkFlags -> VkFlags -> VkFlags
max :: VkFlags -> VkFlags -> VkFlags
$cmax :: VkFlags -> VkFlags -> VkFlags
>= :: VkFlags -> VkFlags -> Bool
$c>= :: VkFlags -> VkFlags -> Bool
> :: VkFlags -> VkFlags -> Bool
$c> :: VkFlags -> VkFlags -> Bool
<= :: VkFlags -> VkFlags -> Bool
$c<= :: VkFlags -> VkFlags -> Bool
< :: VkFlags -> VkFlags -> Bool
$c< :: VkFlags -> VkFlags -> Bool
compare :: VkFlags -> VkFlags -> Ordering
$ccompare :: VkFlags -> VkFlags -> Ordering
$cp1Ord :: Eq VkFlags
Ord, Integer -> VkFlags
VkFlags -> VkFlags
VkFlags -> VkFlags -> VkFlags
(VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags)
-> (VkFlags -> VkFlags)
-> (VkFlags -> VkFlags)
-> (Integer -> VkFlags)
-> Num VkFlags
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> VkFlags
$cfromInteger :: Integer -> VkFlags
signum :: VkFlags -> VkFlags
$csignum :: VkFlags -> VkFlags
abs :: VkFlags -> VkFlags
$cabs :: VkFlags -> VkFlags
negate :: VkFlags -> VkFlags
$cnegate :: VkFlags -> VkFlags
* :: VkFlags -> VkFlags -> VkFlags
$c* :: VkFlags -> VkFlags -> VkFlags
- :: VkFlags -> VkFlags -> VkFlags
$c- :: VkFlags -> VkFlags -> VkFlags
+ :: VkFlags -> VkFlags -> VkFlags
$c+ :: VkFlags -> VkFlags -> VkFlags
Num, VkFlags
VkFlags -> VkFlags -> Bounded VkFlags
forall a. a -> a -> Bounded a
maxBound :: VkFlags
$cmaxBound :: VkFlags
minBound :: VkFlags
$cminBound :: VkFlags
Bounded, Int -> VkFlags
VkFlags -> Int
VkFlags -> [VkFlags]
VkFlags -> VkFlags
VkFlags -> VkFlags -> [VkFlags]
VkFlags -> VkFlags -> VkFlags -> [VkFlags]
(VkFlags -> VkFlags)
-> (VkFlags -> VkFlags)
-> (Int -> VkFlags)
-> (VkFlags -> Int)
-> (VkFlags -> [VkFlags])
-> (VkFlags -> VkFlags -> [VkFlags])
-> (VkFlags -> VkFlags -> [VkFlags])
-> (VkFlags -> VkFlags -> VkFlags -> [VkFlags])
-> Enum VkFlags
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 :: VkFlags -> VkFlags -> VkFlags -> [VkFlags]
$cenumFromThenTo :: VkFlags -> VkFlags -> VkFlags -> [VkFlags]
enumFromTo :: VkFlags -> VkFlags -> [VkFlags]
$cenumFromTo :: VkFlags -> VkFlags -> [VkFlags]
enumFromThen :: VkFlags -> VkFlags -> [VkFlags]
$cenumFromThen :: VkFlags -> VkFlags -> [VkFlags]
enumFrom :: VkFlags -> [VkFlags]
$cenumFrom :: VkFlags -> [VkFlags]
fromEnum :: VkFlags -> Int
$cfromEnum :: VkFlags -> Int
toEnum :: Int -> VkFlags
$ctoEnum :: Int -> VkFlags
pred :: VkFlags -> VkFlags
$cpred :: VkFlags -> VkFlags
succ :: VkFlags -> VkFlags
$csucc :: VkFlags -> VkFlags
Enum, Enum VkFlags
Real VkFlags
Real VkFlags
-> Enum VkFlags
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> (VkFlags, VkFlags))
-> (VkFlags -> VkFlags -> (VkFlags, VkFlags))
-> (VkFlags -> Integer)
-> Integral VkFlags
VkFlags -> Integer
VkFlags -> VkFlags -> (VkFlags, VkFlags)
VkFlags -> VkFlags -> VkFlags
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 :: VkFlags -> Integer
$ctoInteger :: VkFlags -> Integer
divMod :: VkFlags -> VkFlags -> (VkFlags, VkFlags)
$cdivMod :: VkFlags -> VkFlags -> (VkFlags, VkFlags)
quotRem :: VkFlags -> VkFlags -> (VkFlags, VkFlags)
$cquotRem :: VkFlags -> VkFlags -> (VkFlags, VkFlags)
mod :: VkFlags -> VkFlags -> VkFlags
$cmod :: VkFlags -> VkFlags -> VkFlags
div :: VkFlags -> VkFlags -> VkFlags
$cdiv :: VkFlags -> VkFlags -> VkFlags
rem :: VkFlags -> VkFlags -> VkFlags
$crem :: VkFlags -> VkFlags -> VkFlags
quot :: VkFlags -> VkFlags -> VkFlags
$cquot :: VkFlags -> VkFlags -> VkFlags
$cp2Integral :: Enum VkFlags
$cp1Integral :: Real VkFlags
Integral, Eq VkFlags
VkFlags
Eq VkFlags
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags -> VkFlags)
-> (VkFlags -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> VkFlags
-> (Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> Bool)
-> (VkFlags -> Maybe Int)
-> (VkFlags -> Int)
-> (VkFlags -> Bool)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int -> VkFlags)
-> (VkFlags -> Int)
-> Bits VkFlags
Int -> VkFlags
VkFlags -> Bool
VkFlags -> Int
VkFlags -> Maybe Int
VkFlags -> VkFlags
VkFlags -> Int -> Bool
VkFlags -> Int -> VkFlags
VkFlags -> VkFlags -> VkFlags
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
popCount :: VkFlags -> Int
$cpopCount :: VkFlags -> Int
rotateR :: VkFlags -> Int -> VkFlags
$crotateR :: VkFlags -> Int -> VkFlags
rotateL :: VkFlags -> Int -> VkFlags
$crotateL :: VkFlags -> Int -> VkFlags
unsafeShiftR :: VkFlags -> Int -> VkFlags
$cunsafeShiftR :: VkFlags -> Int -> VkFlags
shiftR :: VkFlags -> Int -> VkFlags
$cshiftR :: VkFlags -> Int -> VkFlags
unsafeShiftL :: VkFlags -> Int -> VkFlags
$cunsafeShiftL :: VkFlags -> Int -> VkFlags
shiftL :: VkFlags -> Int -> VkFlags
$cshiftL :: VkFlags -> Int -> VkFlags
isSigned :: VkFlags -> Bool
$cisSigned :: VkFlags -> Bool
bitSize :: VkFlags -> Int
$cbitSize :: VkFlags -> Int
bitSizeMaybe :: VkFlags -> Maybe Int
$cbitSizeMaybe :: VkFlags -> Maybe Int
testBit :: VkFlags -> Int -> Bool
$ctestBit :: VkFlags -> Int -> Bool
complementBit :: VkFlags -> Int -> VkFlags
$ccomplementBit :: VkFlags -> Int -> VkFlags
clearBit :: VkFlags -> Int -> VkFlags
$cclearBit :: VkFlags -> Int -> VkFlags
setBit :: VkFlags -> Int -> VkFlags
$csetBit :: VkFlags -> Int -> VkFlags
bit :: Int -> VkFlags
$cbit :: Int -> VkFlags
zeroBits :: VkFlags
$czeroBits :: VkFlags
rotate :: VkFlags -> Int -> VkFlags
$crotate :: VkFlags -> Int -> VkFlags
shift :: VkFlags -> Int -> VkFlags
$cshift :: VkFlags -> Int -> VkFlags
complement :: VkFlags -> VkFlags
$ccomplement :: VkFlags -> VkFlags
xor :: VkFlags -> VkFlags -> VkFlags
$cxor :: VkFlags -> VkFlags -> VkFlags
.|. :: VkFlags -> VkFlags -> VkFlags
$c.|. :: VkFlags -> VkFlags -> VkFlags
.&. :: VkFlags -> VkFlags -> VkFlags
$c.&. :: VkFlags -> VkFlags -> VkFlags
$cp1Bits :: Eq VkFlags
Bits, Bits VkFlags
Bits VkFlags
-> (VkFlags -> Int)
-> (VkFlags -> Int)
-> (VkFlags -> Int)
-> FiniteBits VkFlags
VkFlags -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkFlags -> Int
$ccountTrailingZeros :: VkFlags -> Int
countLeadingZeros :: VkFlags -> Int
$ccountLeadingZeros :: VkFlags -> Int
finiteBitSize :: VkFlags -> Int
$cfiniteBitSize :: VkFlags -> Int
$cp1FiniteBits :: Bits VkFlags
FiniteBits,
                              Ptr b -> Int -> IO VkFlags
Ptr b -> Int -> VkFlags -> IO ()
Ptr VkFlags -> IO VkFlags
Ptr VkFlags -> Int -> IO VkFlags
Ptr VkFlags -> Int -> VkFlags -> IO ()
Ptr VkFlags -> VkFlags -> IO ()
VkFlags -> Int
(VkFlags -> Int)
-> (VkFlags -> Int)
-> (Ptr VkFlags -> Int -> IO VkFlags)
-> (Ptr VkFlags -> Int -> VkFlags -> IO ())
-> (forall b. Ptr b -> Int -> IO VkFlags)
-> (forall b. Ptr b -> Int -> VkFlags -> IO ())
-> (Ptr VkFlags -> IO VkFlags)
-> (Ptr VkFlags -> VkFlags -> IO ())
-> Storable VkFlags
forall b. Ptr b -> Int -> IO VkFlags
forall b. Ptr b -> Int -> VkFlags -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkFlags -> VkFlags -> IO ()
$cpoke :: Ptr VkFlags -> VkFlags -> IO ()
peek :: Ptr VkFlags -> IO VkFlags
$cpeek :: Ptr VkFlags -> IO VkFlags
pokeByteOff :: Ptr b -> Int -> VkFlags -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkFlags -> IO ()
peekByteOff :: Ptr b -> Int -> IO VkFlags
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkFlags
pokeElemOff :: Ptr VkFlags -> Int -> VkFlags -> IO ()
$cpokeElemOff :: Ptr VkFlags -> Int -> VkFlags -> IO ()
peekElemOff :: Ptr VkFlags -> Int -> IO VkFlags
$cpeekElemOff :: Ptr VkFlags -> Int -> IO VkFlags
alignment :: VkFlags -> Int
$calignment :: VkFlags -> Int
sizeOf :: VkFlags -> Int
$csizeOf :: VkFlags -> Int
Storable, Num VkFlags
Ord VkFlags
Num VkFlags -> Ord VkFlags -> (VkFlags -> Rational) -> Real VkFlags
VkFlags -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: VkFlags -> Rational
$ctoRational :: VkFlags -> Rational
$cp2Real :: Ord VkFlags
$cp1Real :: Num VkFlags
Real, Typeable VkFlags
DataType
Constr
Typeable VkFlags
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VkFlags -> c VkFlags)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c VkFlags)
-> (VkFlags -> Constr)
-> (VkFlags -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c VkFlags))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkFlags))
-> ((forall b. Data b => b -> b) -> VkFlags -> VkFlags)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VkFlags -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VkFlags -> r)
-> (forall u. (forall d. Data d => d -> u) -> VkFlags -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> VkFlags -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> VkFlags -> m VkFlags)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VkFlags -> m VkFlags)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VkFlags -> m VkFlags)
-> Data VkFlags
VkFlags -> DataType
VkFlags -> Constr
(forall b. Data b => b -> b) -> VkFlags -> VkFlags
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkFlags -> c VkFlags
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkFlags
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> VkFlags -> u
forall u. (forall d. Data d => d -> u) -> VkFlags -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkFlags -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkFlags -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VkFlags -> m VkFlags
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VkFlags -> m VkFlags
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkFlags
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkFlags -> c VkFlags
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VkFlags)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkFlags)
$cVkFlags :: Constr
$tVkFlags :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> VkFlags -> m VkFlags
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VkFlags -> m VkFlags
gmapMp :: (forall d. Data d => d -> m d) -> VkFlags -> m VkFlags
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VkFlags -> m VkFlags
gmapM :: (forall d. Data d => d -> m d) -> VkFlags -> m VkFlags
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VkFlags -> m VkFlags
gmapQi :: Int -> (forall d. Data d => d -> u) -> VkFlags -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VkFlags -> u
gmapQ :: (forall d. Data d => d -> u) -> VkFlags -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VkFlags -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkFlags -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkFlags -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkFlags -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkFlags -> r
gmapT :: (forall b. Data b => b -> b) -> VkFlags -> VkFlags
$cgmapT :: (forall b. Data b => b -> b) -> VkFlags -> VkFlags
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkFlags)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkFlags)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c VkFlags)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VkFlags)
dataTypeOf :: VkFlags -> DataType
$cdataTypeOf :: VkFlags -> DataType
toConstr :: VkFlags -> Constr
$ctoConstr :: VkFlags -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkFlags
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkFlags
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkFlags -> c VkFlags
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkFlags -> c VkFlags
$cp1Data :: Typeable VkFlags
Data, (forall x. VkFlags -> Rep VkFlags x)
-> (forall x. Rep VkFlags x -> VkFlags) -> Generic VkFlags
forall x. Rep VkFlags x -> VkFlags
forall x. VkFlags -> Rep VkFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VkFlags x -> VkFlags
$cfrom :: forall x. VkFlags -> Rep VkFlags x
Generic)

instance Show VkFlags where
        {-# INLINE show #-}
        show :: VkFlags -> String
show (VkFlags Word32
x) = Word32 -> String
forall a. Show a => a -> String
show Word32
x

instance Read VkFlags where
        {-# INLINE readsPrec #-}
        readsPrec :: Int -> ReadS VkFlags
readsPrec = (Int -> ReadS Word32) -> Int -> ReadS VkFlags
coerce (Int -> ReadS Word32
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS Word32)

newtype VkSampleMask = VkSampleMask Word32
                         deriving (VkSampleMask -> VkSampleMask -> Bool
(VkSampleMask -> VkSampleMask -> Bool)
-> (VkSampleMask -> VkSampleMask -> Bool) -> Eq VkSampleMask
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkSampleMask -> VkSampleMask -> Bool
$c/= :: VkSampleMask -> VkSampleMask -> Bool
== :: VkSampleMask -> VkSampleMask -> Bool
$c== :: VkSampleMask -> VkSampleMask -> Bool
Eq, Eq VkSampleMask
Eq VkSampleMask
-> (VkSampleMask -> VkSampleMask -> Ordering)
-> (VkSampleMask -> VkSampleMask -> Bool)
-> (VkSampleMask -> VkSampleMask -> Bool)
-> (VkSampleMask -> VkSampleMask -> Bool)
-> (VkSampleMask -> VkSampleMask -> Bool)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> Ord VkSampleMask
VkSampleMask -> VkSampleMask -> Bool
VkSampleMask -> VkSampleMask -> Ordering
VkSampleMask -> VkSampleMask -> VkSampleMask
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
min :: VkSampleMask -> VkSampleMask -> VkSampleMask
$cmin :: VkSampleMask -> VkSampleMask -> VkSampleMask
max :: VkSampleMask -> VkSampleMask -> VkSampleMask
$cmax :: VkSampleMask -> VkSampleMask -> VkSampleMask
>= :: VkSampleMask -> VkSampleMask -> Bool
$c>= :: VkSampleMask -> VkSampleMask -> Bool
> :: VkSampleMask -> VkSampleMask -> Bool
$c> :: VkSampleMask -> VkSampleMask -> Bool
<= :: VkSampleMask -> VkSampleMask -> Bool
$c<= :: VkSampleMask -> VkSampleMask -> Bool
< :: VkSampleMask -> VkSampleMask -> Bool
$c< :: VkSampleMask -> VkSampleMask -> Bool
compare :: VkSampleMask -> VkSampleMask -> Ordering
$ccompare :: VkSampleMask -> VkSampleMask -> Ordering
$cp1Ord :: Eq VkSampleMask
Ord, Integer -> VkSampleMask
VkSampleMask -> VkSampleMask
VkSampleMask -> VkSampleMask -> VkSampleMask
(VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask)
-> (Integer -> VkSampleMask)
-> Num VkSampleMask
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> VkSampleMask
$cfromInteger :: Integer -> VkSampleMask
signum :: VkSampleMask -> VkSampleMask
$csignum :: VkSampleMask -> VkSampleMask
abs :: VkSampleMask -> VkSampleMask
$cabs :: VkSampleMask -> VkSampleMask
negate :: VkSampleMask -> VkSampleMask
$cnegate :: VkSampleMask -> VkSampleMask
* :: VkSampleMask -> VkSampleMask -> VkSampleMask
$c* :: VkSampleMask -> VkSampleMask -> VkSampleMask
- :: VkSampleMask -> VkSampleMask -> VkSampleMask
$c- :: VkSampleMask -> VkSampleMask -> VkSampleMask
+ :: VkSampleMask -> VkSampleMask -> VkSampleMask
$c+ :: VkSampleMask -> VkSampleMask -> VkSampleMask
Num, VkSampleMask
VkSampleMask -> VkSampleMask -> Bounded VkSampleMask
forall a. a -> a -> Bounded a
maxBound :: VkSampleMask
$cmaxBound :: VkSampleMask
minBound :: VkSampleMask
$cminBound :: VkSampleMask
Bounded, Int -> VkSampleMask
VkSampleMask -> Int
VkSampleMask -> [VkSampleMask]
VkSampleMask -> VkSampleMask
VkSampleMask -> VkSampleMask -> [VkSampleMask]
VkSampleMask -> VkSampleMask -> VkSampleMask -> [VkSampleMask]
(VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask)
-> (Int -> VkSampleMask)
-> (VkSampleMask -> Int)
-> (VkSampleMask -> [VkSampleMask])
-> (VkSampleMask -> VkSampleMask -> [VkSampleMask])
-> (VkSampleMask -> VkSampleMask -> [VkSampleMask])
-> (VkSampleMask -> VkSampleMask -> VkSampleMask -> [VkSampleMask])
-> Enum VkSampleMask
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 :: VkSampleMask -> VkSampleMask -> VkSampleMask -> [VkSampleMask]
$cenumFromThenTo :: VkSampleMask -> VkSampleMask -> VkSampleMask -> [VkSampleMask]
enumFromTo :: VkSampleMask -> VkSampleMask -> [VkSampleMask]
$cenumFromTo :: VkSampleMask -> VkSampleMask -> [VkSampleMask]
enumFromThen :: VkSampleMask -> VkSampleMask -> [VkSampleMask]
$cenumFromThen :: VkSampleMask -> VkSampleMask -> [VkSampleMask]
enumFrom :: VkSampleMask -> [VkSampleMask]
$cenumFrom :: VkSampleMask -> [VkSampleMask]
fromEnum :: VkSampleMask -> Int
$cfromEnum :: VkSampleMask -> Int
toEnum :: Int -> VkSampleMask
$ctoEnum :: Int -> VkSampleMask
pred :: VkSampleMask -> VkSampleMask
$cpred :: VkSampleMask -> VkSampleMask
succ :: VkSampleMask -> VkSampleMask
$csucc :: VkSampleMask -> VkSampleMask
Enum, Enum VkSampleMask
Real VkSampleMask
Real VkSampleMask
-> Enum VkSampleMask
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask))
-> (VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask))
-> (VkSampleMask -> Integer)
-> Integral VkSampleMask
VkSampleMask -> Integer
VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask)
VkSampleMask -> VkSampleMask -> VkSampleMask
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 :: VkSampleMask -> Integer
$ctoInteger :: VkSampleMask -> Integer
divMod :: VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask)
$cdivMod :: VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask)
quotRem :: VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask)
$cquotRem :: VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask)
mod :: VkSampleMask -> VkSampleMask -> VkSampleMask
$cmod :: VkSampleMask -> VkSampleMask -> VkSampleMask
div :: VkSampleMask -> VkSampleMask -> VkSampleMask
$cdiv :: VkSampleMask -> VkSampleMask -> VkSampleMask
rem :: VkSampleMask -> VkSampleMask -> VkSampleMask
$crem :: VkSampleMask -> VkSampleMask -> VkSampleMask
quot :: VkSampleMask -> VkSampleMask -> VkSampleMask
$cquot :: VkSampleMask -> VkSampleMask -> VkSampleMask
$cp2Integral :: Enum VkSampleMask
$cp1Integral :: Real VkSampleMask
Integral, Eq VkSampleMask
VkSampleMask
Eq VkSampleMask
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> VkSampleMask
-> (Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> Bool)
-> (VkSampleMask -> Maybe Int)
-> (VkSampleMask -> Int)
-> (VkSampleMask -> Bool)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int -> VkSampleMask)
-> (VkSampleMask -> Int)
-> Bits VkSampleMask
Int -> VkSampleMask
VkSampleMask -> Bool
VkSampleMask -> Int
VkSampleMask -> Maybe Int
VkSampleMask -> VkSampleMask
VkSampleMask -> Int -> Bool
VkSampleMask -> Int -> VkSampleMask
VkSampleMask -> VkSampleMask -> VkSampleMask
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
popCount :: VkSampleMask -> Int
$cpopCount :: VkSampleMask -> Int
rotateR :: VkSampleMask -> Int -> VkSampleMask
$crotateR :: VkSampleMask -> Int -> VkSampleMask
rotateL :: VkSampleMask -> Int -> VkSampleMask
$crotateL :: VkSampleMask -> Int -> VkSampleMask
unsafeShiftR :: VkSampleMask -> Int -> VkSampleMask
$cunsafeShiftR :: VkSampleMask -> Int -> VkSampleMask
shiftR :: VkSampleMask -> Int -> VkSampleMask
$cshiftR :: VkSampleMask -> Int -> VkSampleMask
unsafeShiftL :: VkSampleMask -> Int -> VkSampleMask
$cunsafeShiftL :: VkSampleMask -> Int -> VkSampleMask
shiftL :: VkSampleMask -> Int -> VkSampleMask
$cshiftL :: VkSampleMask -> Int -> VkSampleMask
isSigned :: VkSampleMask -> Bool
$cisSigned :: VkSampleMask -> Bool
bitSize :: VkSampleMask -> Int
$cbitSize :: VkSampleMask -> Int
bitSizeMaybe :: VkSampleMask -> Maybe Int
$cbitSizeMaybe :: VkSampleMask -> Maybe Int
testBit :: VkSampleMask -> Int -> Bool
$ctestBit :: VkSampleMask -> Int -> Bool
complementBit :: VkSampleMask -> Int -> VkSampleMask
$ccomplementBit :: VkSampleMask -> Int -> VkSampleMask
clearBit :: VkSampleMask -> Int -> VkSampleMask
$cclearBit :: VkSampleMask -> Int -> VkSampleMask
setBit :: VkSampleMask -> Int -> VkSampleMask
$csetBit :: VkSampleMask -> Int -> VkSampleMask
bit :: Int -> VkSampleMask
$cbit :: Int -> VkSampleMask
zeroBits :: VkSampleMask
$czeroBits :: VkSampleMask
rotate :: VkSampleMask -> Int -> VkSampleMask
$crotate :: VkSampleMask -> Int -> VkSampleMask
shift :: VkSampleMask -> Int -> VkSampleMask
$cshift :: VkSampleMask -> Int -> VkSampleMask
complement :: VkSampleMask -> VkSampleMask
$ccomplement :: VkSampleMask -> VkSampleMask
xor :: VkSampleMask -> VkSampleMask -> VkSampleMask
$cxor :: VkSampleMask -> VkSampleMask -> VkSampleMask
.|. :: VkSampleMask -> VkSampleMask -> VkSampleMask
$c.|. :: VkSampleMask -> VkSampleMask -> VkSampleMask
.&. :: VkSampleMask -> VkSampleMask -> VkSampleMask
$c.&. :: VkSampleMask -> VkSampleMask -> VkSampleMask
$cp1Bits :: Eq VkSampleMask
Bits, Bits VkSampleMask
Bits VkSampleMask
-> (VkSampleMask -> Int)
-> (VkSampleMask -> Int)
-> (VkSampleMask -> Int)
-> FiniteBits VkSampleMask
VkSampleMask -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: VkSampleMask -> Int
$ccountTrailingZeros :: VkSampleMask -> Int
countLeadingZeros :: VkSampleMask -> Int
$ccountLeadingZeros :: VkSampleMask -> Int
finiteBitSize :: VkSampleMask -> Int
$cfiniteBitSize :: VkSampleMask -> Int
$cp1FiniteBits :: Bits VkSampleMask
FiniteBits,
                                   Ptr b -> Int -> IO VkSampleMask
Ptr b -> Int -> VkSampleMask -> IO ()
Ptr VkSampleMask -> IO VkSampleMask
Ptr VkSampleMask -> Int -> IO VkSampleMask
Ptr VkSampleMask -> Int -> VkSampleMask -> IO ()
Ptr VkSampleMask -> VkSampleMask -> IO ()
VkSampleMask -> Int
(VkSampleMask -> Int)
-> (VkSampleMask -> Int)
-> (Ptr VkSampleMask -> Int -> IO VkSampleMask)
-> (Ptr VkSampleMask -> Int -> VkSampleMask -> IO ())
-> (forall b. Ptr b -> Int -> IO VkSampleMask)
-> (forall b. Ptr b -> Int -> VkSampleMask -> IO ())
-> (Ptr VkSampleMask -> IO VkSampleMask)
-> (Ptr VkSampleMask -> VkSampleMask -> IO ())
-> Storable VkSampleMask
forall b. Ptr b -> Int -> IO VkSampleMask
forall b. Ptr b -> Int -> VkSampleMask -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr VkSampleMask -> VkSampleMask -> IO ()
$cpoke :: Ptr VkSampleMask -> VkSampleMask -> IO ()
peek :: Ptr VkSampleMask -> IO VkSampleMask
$cpeek :: Ptr VkSampleMask -> IO VkSampleMask
pokeByteOff :: Ptr b -> Int -> VkSampleMask -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkSampleMask -> IO ()
peekByteOff :: Ptr b -> Int -> IO VkSampleMask
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkSampleMask
pokeElemOff :: Ptr VkSampleMask -> Int -> VkSampleMask -> IO ()
$cpokeElemOff :: Ptr VkSampleMask -> Int -> VkSampleMask -> IO ()
peekElemOff :: Ptr VkSampleMask -> Int -> IO VkSampleMask
$cpeekElemOff :: Ptr VkSampleMask -> Int -> IO VkSampleMask
alignment :: VkSampleMask -> Int
$calignment :: VkSampleMask -> Int
sizeOf :: VkSampleMask -> Int
$csizeOf :: VkSampleMask -> Int
Storable, Num VkSampleMask
Ord VkSampleMask
Num VkSampleMask
-> Ord VkSampleMask
-> (VkSampleMask -> Rational)
-> Real VkSampleMask
VkSampleMask -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: VkSampleMask -> Rational
$ctoRational :: VkSampleMask -> Rational
$cp2Real :: Ord VkSampleMask
$cp1Real :: Num VkSampleMask
Real, Typeable VkSampleMask
DataType
Constr
Typeable VkSampleMask
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VkSampleMask -> c VkSampleMask)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c VkSampleMask)
-> (VkSampleMask -> Constr)
-> (VkSampleMask -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c VkSampleMask))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c VkSampleMask))
-> ((forall b. Data b => b -> b) -> VkSampleMask -> VkSampleMask)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VkSampleMask -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VkSampleMask -> r)
-> (forall u. (forall d. Data d => d -> u) -> VkSampleMask -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> VkSampleMask -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> VkSampleMask -> m VkSampleMask)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VkSampleMask -> m VkSampleMask)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VkSampleMask -> m VkSampleMask)
-> Data VkSampleMask
VkSampleMask -> DataType
VkSampleMask -> Constr
(forall b. Data b => b -> b) -> VkSampleMask -> VkSampleMask
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkSampleMask -> c VkSampleMask
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkSampleMask
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> VkSampleMask -> u
forall u. (forall d. Data d => d -> u) -> VkSampleMask -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkSampleMask -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkSampleMask -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VkSampleMask -> m VkSampleMask
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VkSampleMask -> m VkSampleMask
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkSampleMask
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkSampleMask -> c VkSampleMask
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VkSampleMask)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VkSampleMask)
$cVkSampleMask :: Constr
$tVkSampleMask :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> VkSampleMask -> m VkSampleMask
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VkSampleMask -> m VkSampleMask
gmapMp :: (forall d. Data d => d -> m d) -> VkSampleMask -> m VkSampleMask
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VkSampleMask -> m VkSampleMask
gmapM :: (forall d. Data d => d -> m d) -> VkSampleMask -> m VkSampleMask
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VkSampleMask -> m VkSampleMask
gmapQi :: Int -> (forall d. Data d => d -> u) -> VkSampleMask -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VkSampleMask -> u
gmapQ :: (forall d. Data d => d -> u) -> VkSampleMask -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VkSampleMask -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkSampleMask -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VkSampleMask -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkSampleMask -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VkSampleMask -> r
gmapT :: (forall b. Data b => b -> b) -> VkSampleMask -> VkSampleMask
$cgmapT :: (forall b. Data b => b -> b) -> VkSampleMask -> VkSampleMask
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VkSampleMask)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VkSampleMask)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c VkSampleMask)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VkSampleMask)
dataTypeOf :: VkSampleMask -> DataType
$cdataTypeOf :: VkSampleMask -> DataType
toConstr :: VkSampleMask -> Constr
$ctoConstr :: VkSampleMask -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkSampleMask
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VkSampleMask
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkSampleMask -> c VkSampleMask
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VkSampleMask -> c VkSampleMask
$cp1Data :: Typeable VkSampleMask
Data, (forall x. VkSampleMask -> Rep VkSampleMask x)
-> (forall x. Rep VkSampleMask x -> VkSampleMask)
-> Generic VkSampleMask
forall x. Rep VkSampleMask x -> VkSampleMask
forall x. VkSampleMask -> Rep VkSampleMask x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VkSampleMask x -> VkSampleMask
$cfrom :: forall x. VkSampleMask -> Rep VkSampleMask x
Generic)

instance Show VkSampleMask where
        {-# INLINE show #-}
        show :: VkSampleMask -> String
show (VkSampleMask Word32
x) = Word32 -> String
forall a. Show a => a -> String
show Word32
x

instance Read VkSampleMask where
        {-# INLINE readsPrec #-}
        readsPrec :: Int -> ReadS VkSampleMask
readsPrec = (Int -> ReadS Word32) -> Int -> ReadS VkSampleMask
coerce (Int -> ReadS Word32
forall a. Read a => Int -> ReadS a
readsPrec :: Int -> ReadS Word32)