{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE EmptyDataDecls #-}
{-# LANGUAGE ExplicitForAll #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE NoFieldSelectors #-}
{-# LANGUAGE NoImplicitPrelude #-}

module SDL3.Sys.Bindgen.Stdinc (
  SDL3.Sys.Bindgen.Stdinc.Sint8 (..),
  SDL3.Sys.Bindgen.Stdinc.Uint8 (..),
  SDL3.Sys.Bindgen.Stdinc.Sint16 (..),
  SDL3.Sys.Bindgen.Stdinc.Uint16 (..),
  SDL3.Sys.Bindgen.Stdinc.Sint32 (..),
  SDL3.Sys.Bindgen.Stdinc.Uint32 (..),
  SDL3.Sys.Bindgen.Stdinc.Sint64 (..),
  SDL3.Sys.Bindgen.Stdinc.Uint64 (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_Time (..),
  SDL3.Sys.Bindgen.Stdinc.sDL_FLT_EPSILON,
  SDL3.Sys.Bindgen.Stdinc.sDL_PRILL_PREFIX,
  SDL3.Sys.Bindgen.Stdinc.SDL_alignment_test (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_DUMMY_ENUM (..),
  pattern SDL3.Sys.Bindgen.Stdinc.DUMMY_ENUM_VALUE,
  SDL3.Sys.Bindgen.Stdinc.SDL_malloc_func_Aux (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_malloc_func (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_calloc_func_Aux (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_calloc_func (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_realloc_func_Aux (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_realloc_func (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_free_func_Aux (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_free_func (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_Environment,
  SDL3.Sys.Bindgen.Stdinc.SDL_CompareCallback_Aux (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_CompareCallback (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_CompareCallback_r_Aux (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_CompareCallback_r (..),
  SDL3.Sys.Bindgen.Stdinc.sDL_INVALID_UNICODE_CODEPOINT,
  SDL3.Sys.Bindgen.Stdinc.sDL_PI_D,
  SDL3.Sys.Bindgen.Stdinc.sDL_PI_F,
  SDL3.Sys.Bindgen.Stdinc.SDL_iconv_data_t,
  SDL3.Sys.Bindgen.Stdinc.SDL_iconv_t (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_FunctionPointer_Aux (..),
  SDL3.Sys.Bindgen.Stdinc.SDL_FunctionPointer (..),
)
where

import Prelude (
  Bounded,
  Enum,
  Eq,
  IO,
  Int,
  Integral,
  Num,
  Ord,
  Read,
  Real,
  Show,
  fmap,
  pure,
  (<*>),
  (>>),
  type (~),
 )

import HsBindgen.Runtime.CEnum qualified as CEnum
import HsBindgen.Runtime.HasCField qualified as HasCField
import HsBindgen.Runtime.LibC qualified
import HsBindgen.Runtime.Marshal qualified as Marshal
import HsBindgen.Runtime.PtrConst qualified as PtrConst
import HsBindgen.Runtime.Struct qualified as Struct
import HsBindgen.Runtime.Support qualified as BG
import HsBindgen.Runtime.Support.CompatHasField qualified as BG.CompatHasField

-- | A signed 8-bit integer type.
--
--     @since 3.2.0
--
--     [C declaration]: @Sint8@, defined at @SDL3\/SDL_stdinc.h 437:16@
newtype Sint8 = Sint8
  { Sint8 -> Int8
unwrap :: HsBindgen.Runtime.LibC.Int8
  }
  deriving stock ((forall x. Sint8 -> Rep Sint8 x)
-> (forall x. Rep Sint8 x -> Sint8) -> Generic Sint8
forall x. Rep Sint8 x -> Sint8
forall x. Sint8 -> Rep Sint8 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Sint8 -> Rep Sint8 x
from :: forall x. Sint8 -> Rep Sint8 x
$cto :: forall x. Rep Sint8 x -> Sint8
to :: forall x. Rep Sint8 x -> Sint8
BG.Generic, Sint8 -> Sint8 -> Bool
(Sint8 -> Sint8 -> Bool) -> (Sint8 -> Sint8 -> Bool) -> Eq Sint8
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Sint8 -> Sint8 -> Bool
== :: Sint8 -> Sint8 -> Bool
$c/= :: Sint8 -> Sint8 -> Bool
/= :: Sint8 -> Sint8 -> Bool
Eq, Eq Sint8
Eq Sint8 =>
(Sint8 -> Sint8 -> Ordering)
-> (Sint8 -> Sint8 -> Bool)
-> (Sint8 -> Sint8 -> Bool)
-> (Sint8 -> Sint8 -> Bool)
-> (Sint8 -> Sint8 -> Bool)
-> (Sint8 -> Sint8 -> Sint8)
-> (Sint8 -> Sint8 -> Sint8)
-> Ord Sint8
Sint8 -> Sint8 -> Bool
Sint8 -> Sint8 -> Ordering
Sint8 -> Sint8 -> Sint8
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
$ccompare :: Sint8 -> Sint8 -> Ordering
compare :: Sint8 -> Sint8 -> Ordering
$c< :: Sint8 -> Sint8 -> Bool
< :: Sint8 -> Sint8 -> Bool
$c<= :: Sint8 -> Sint8 -> Bool
<= :: Sint8 -> Sint8 -> Bool
$c> :: Sint8 -> Sint8 -> Bool
> :: Sint8 -> Sint8 -> Bool
$c>= :: Sint8 -> Sint8 -> Bool
>= :: Sint8 -> Sint8 -> Bool
$cmax :: Sint8 -> Sint8 -> Sint8
max :: Sint8 -> Sint8 -> Sint8
$cmin :: Sint8 -> Sint8 -> Sint8
min :: Sint8 -> Sint8 -> Sint8
Ord, ReadPrec [Sint8]
ReadPrec Sint8
Int -> ReadS Sint8
ReadS [Sint8]
(Int -> ReadS Sint8)
-> ReadS [Sint8]
-> ReadPrec Sint8
-> ReadPrec [Sint8]
-> Read Sint8
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Sint8
readsPrec :: Int -> ReadS Sint8
$creadList :: ReadS [Sint8]
readList :: ReadS [Sint8]
$creadPrec :: ReadPrec Sint8
readPrec :: ReadPrec Sint8
$creadListPrec :: ReadPrec [Sint8]
readListPrec :: ReadPrec [Sint8]
Read, Int -> Sint8 -> ShowS
[Sint8] -> ShowS
Sint8 -> String
(Int -> Sint8 -> ShowS)
-> (Sint8 -> String) -> ([Sint8] -> ShowS) -> Show Sint8
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Sint8 -> ShowS
showsPrec :: Int -> Sint8 -> ShowS
$cshow :: Sint8 -> String
show :: Sint8 -> String
$cshowList :: [Sint8] -> ShowS
showList :: [Sint8] -> ShowS
Show)
  deriving newtype
    ( Word64 -> Int -> Sint8
Sint8 -> Int -> Word64
(Sint8 -> Int -> Word64)
-> (Word64 -> Int -> Sint8) -> Bitfield Sint8
forall a.
(a -> Int -> Word64) -> (Word64 -> Int -> a) -> Bitfield a
$cnarrow :: Sint8 -> Int -> Word64
narrow :: Sint8 -> Int -> Word64
$cextend :: Word64 -> Int -> Sint8
extend :: Word64 -> Int -> Sint8
BG.Bitfield
    , Eq Sint8
Sint8
Eq Sint8 =>
(Sint8 -> Sint8 -> Sint8)
-> (Sint8 -> Sint8 -> Sint8)
-> (Sint8 -> Sint8 -> Sint8)
-> (Sint8 -> Sint8)
-> (Sint8 -> Int -> Sint8)
-> (Sint8 -> Int -> Sint8)
-> Sint8
-> (Int -> Sint8)
-> (Sint8 -> Int -> Sint8)
-> (Sint8 -> Int -> Sint8)
-> (Sint8 -> Int -> Sint8)
-> (Sint8 -> Int -> Bool)
-> (Sint8 -> Maybe Int)
-> (Sint8 -> Int)
-> (Sint8 -> Bool)
-> (Sint8 -> Int -> Sint8)
-> (Sint8 -> Int -> Sint8)
-> (Sint8 -> Int -> Sint8)
-> (Sint8 -> Int -> Sint8)
-> (Sint8 -> Int -> Sint8)
-> (Sint8 -> Int -> Sint8)
-> (Sint8 -> Int)
-> Bits Sint8
Int -> Sint8
Sint8 -> Bool
Sint8 -> Int
Sint8 -> Maybe Int
Sint8 -> Sint8
Sint8 -> Int -> Bool
Sint8 -> Int -> Sint8
Sint8 -> Sint8 -> Sint8
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
$c.&. :: Sint8 -> Sint8 -> Sint8
.&. :: Sint8 -> Sint8 -> Sint8
$c.|. :: Sint8 -> Sint8 -> Sint8
.|. :: Sint8 -> Sint8 -> Sint8
$cxor :: Sint8 -> Sint8 -> Sint8
xor :: Sint8 -> Sint8 -> Sint8
$ccomplement :: Sint8 -> Sint8
complement :: Sint8 -> Sint8
$cshift :: Sint8 -> Int -> Sint8
shift :: Sint8 -> Int -> Sint8
$crotate :: Sint8 -> Int -> Sint8
rotate :: Sint8 -> Int -> Sint8
$czeroBits :: Sint8
zeroBits :: Sint8
$cbit :: Int -> Sint8
bit :: Int -> Sint8
$csetBit :: Sint8 -> Int -> Sint8
setBit :: Sint8 -> Int -> Sint8
$cclearBit :: Sint8 -> Int -> Sint8
clearBit :: Sint8 -> Int -> Sint8
$ccomplementBit :: Sint8 -> Int -> Sint8
complementBit :: Sint8 -> Int -> Sint8
$ctestBit :: Sint8 -> Int -> Bool
testBit :: Sint8 -> Int -> Bool
$cbitSizeMaybe :: Sint8 -> Maybe Int
bitSizeMaybe :: Sint8 -> Maybe Int
$cbitSize :: Sint8 -> Int
bitSize :: Sint8 -> Int
$cisSigned :: Sint8 -> Bool
isSigned :: Sint8 -> Bool
$cshiftL :: Sint8 -> Int -> Sint8
shiftL :: Sint8 -> Int -> Sint8
$cunsafeShiftL :: Sint8 -> Int -> Sint8
unsafeShiftL :: Sint8 -> Int -> Sint8
$cshiftR :: Sint8 -> Int -> Sint8
shiftR :: Sint8 -> Int -> Sint8
$cunsafeShiftR :: Sint8 -> Int -> Sint8
unsafeShiftR :: Sint8 -> Int -> Sint8
$crotateL :: Sint8 -> Int -> Sint8
rotateL :: Sint8 -> Int -> Sint8
$crotateR :: Sint8 -> Int -> Sint8
rotateR :: Sint8 -> Int -> Sint8
$cpopCount :: Sint8 -> Int
popCount :: Sint8 -> Int
BG.Bits
    , Bits Sint8
Bits Sint8 =>
(Sint8 -> Int)
-> (Sint8 -> Int) -> (Sint8 -> Int) -> FiniteBits Sint8
Sint8 -> Int
forall b.
Bits b =>
(b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
$cfiniteBitSize :: Sint8 -> Int
finiteBitSize :: Sint8 -> Int
$ccountLeadingZeros :: Sint8 -> Int
countLeadingZeros :: Sint8 -> Int
$ccountTrailingZeros :: Sint8 -> Int
countTrailingZeros :: Sint8 -> Int
BG.FiniteBits
    , FFIType Sint8 -> Sint8
Sint8 -> FFIType Sint8
(Sint8 -> FFIType Sint8)
-> (FFIType Sint8 -> Sint8) -> HasFFIType Sint8
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: Sint8 -> FFIType Sint8
toFFIType :: Sint8 -> FFIType Sint8
$cfromFFIType :: FFIType Sint8 -> Sint8
fromFFIType :: FFIType Sint8 -> Sint8
BG.HasFFIType
    , Ord Sint8
Ord Sint8 =>
((Sint8, Sint8) -> [Sint8])
-> ((Sint8, Sint8) -> Sint8 -> Int)
-> ((Sint8, Sint8) -> Sint8 -> Int)
-> ((Sint8, Sint8) -> Sint8 -> Bool)
-> ((Sint8, Sint8) -> Int)
-> ((Sint8, Sint8) -> Int)
-> Ix Sint8
(Sint8, Sint8) -> Int
(Sint8, Sint8) -> [Sint8]
(Sint8, Sint8) -> Sint8 -> Bool
(Sint8, Sint8) -> Sint8 -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
$crange :: (Sint8, Sint8) -> [Sint8]
range :: (Sint8, Sint8) -> [Sint8]
$cindex :: (Sint8, Sint8) -> Sint8 -> Int
index :: (Sint8, Sint8) -> Sint8 -> Int
$cunsafeIndex :: (Sint8, Sint8) -> Sint8 -> Int
unsafeIndex :: (Sint8, Sint8) -> Sint8 -> Int
$cinRange :: (Sint8, Sint8) -> Sint8 -> Bool
inRange :: (Sint8, Sint8) -> Sint8 -> Bool
$crangeSize :: (Sint8, Sint8) -> Int
rangeSize :: (Sint8, Sint8) -> Int
$cunsafeRangeSize :: (Sint8, Sint8) -> Int
unsafeRangeSize :: (Sint8, Sint8) -> Int
BG.Ix
    , Addr# -> Int# -> Sint8
ByteArray# -> Int# -> Sint8
Proxy Sint8 -> Int#
Sint8 -> Int#
(Proxy Sint8 -> Int#)
-> (Sint8 -> Int#)
-> (Proxy Sint8 -> Int#)
-> (Sint8 -> Int#)
-> (ByteArray# -> Int# -> Sint8)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint8 #))
-> (forall s.
    MutableByteArray# s -> Int# -> Sint8 -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s
    -> Int# -> Int# -> Sint8 -> State# s -> State# s)
-> (Addr# -> Int# -> Sint8)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, Sint8 #))
-> (forall s. Addr# -> Int# -> Sint8 -> State# s -> State# s)
-> (forall s.
    Addr# -> Int# -> Int# -> Sint8 -> State# s -> State# s)
-> Prim Sint8
forall s. Addr# -> Int# -> Int# -> Sint8 -> State# s -> State# s
forall s. Addr# -> Int# -> State# s -> (# State# s, Sint8 #)
forall s. Addr# -> Int# -> Sint8 -> State# s -> State# s
forall s.
MutableByteArray# s
-> Int# -> Int# -> Sint8 -> State# s -> State# s
forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint8 #)
forall s.
MutableByteArray# s -> Int# -> Sint8 -> State# s -> State# s
forall a.
(Proxy a -> Int#)
-> (a -> Int#)
-> (Proxy a -> Int#)
-> (a -> Int#)
-> (ByteArray# -> Int# -> a)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, a #))
-> (forall s.
    MutableByteArray# s -> Int# -> a -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s)
-> (Addr# -> Int# -> a)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, a #))
-> (forall s. Addr# -> Int# -> a -> State# s -> State# s)
-> (forall s. Addr# -> Int# -> Int# -> a -> State# s -> State# s)
-> Prim a
$csizeOfType# :: Proxy Sint8 -> Int#
sizeOfType# :: Proxy Sint8 -> Int#
$csizeOf# :: Sint8 -> Int#
sizeOf# :: Sint8 -> Int#
$calignmentOfType# :: Proxy Sint8 -> Int#
alignmentOfType# :: Proxy Sint8 -> Int#
$calignment# :: Sint8 -> Int#
alignment# :: Sint8 -> Int#
$cindexByteArray# :: ByteArray# -> Int# -> Sint8
indexByteArray# :: ByteArray# -> Int# -> Sint8
$creadByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint8 #)
readByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint8 #)
$cwriteByteArray# :: forall s.
MutableByteArray# s -> Int# -> Sint8 -> State# s -> State# s
writeByteArray# :: forall s.
MutableByteArray# s -> Int# -> Sint8 -> State# s -> State# s
$csetByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Sint8 -> State# s -> State# s
setByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Sint8 -> State# s -> State# s
$cindexOffAddr# :: Addr# -> Int# -> Sint8
indexOffAddr# :: Addr# -> Int# -> Sint8
$creadOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Sint8 #)
readOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Sint8 #)
$cwriteOffAddr# :: forall s. Addr# -> Int# -> Sint8 -> State# s -> State# s
writeOffAddr# :: forall s. Addr# -> Int# -> Sint8 -> State# s -> State# s
$csetOffAddr# :: forall s. Addr# -> Int# -> Int# -> Sint8 -> State# s -> State# s
setOffAddr# :: forall s. Addr# -> Int# -> Int# -> Sint8 -> State# s -> State# s
BG.Prim
    , Ptr Sint8 -> IO Sint8
Ptr Sint8 -> Int -> IO Sint8
Ptr Sint8 -> Int -> Sint8 -> IO ()
Ptr Sint8 -> Sint8 -> IO ()
Sint8 -> Int
(Sint8 -> Int)
-> (Sint8 -> Int)
-> (Ptr Sint8 -> Int -> IO Sint8)
-> (Ptr Sint8 -> Int -> Sint8 -> IO ())
-> (forall b. Ptr b -> Int -> IO Sint8)
-> (forall b. Ptr b -> Int -> Sint8 -> IO ())
-> (Ptr Sint8 -> IO Sint8)
-> (Ptr Sint8 -> Sint8 -> IO ())
-> Storable Sint8
forall b. Ptr b -> Int -> IO Sint8
forall b. Ptr b -> Int -> Sint8 -> 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
$csizeOf :: Sint8 -> Int
sizeOf :: Sint8 -> Int
$calignment :: Sint8 -> Int
alignment :: Sint8 -> Int
$cpeekElemOff :: Ptr Sint8 -> Int -> IO Sint8
peekElemOff :: Ptr Sint8 -> Int -> IO Sint8
$cpokeElemOff :: Ptr Sint8 -> Int -> Sint8 -> IO ()
pokeElemOff :: Ptr Sint8 -> Int -> Sint8 -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Sint8
peekByteOff :: forall b. Ptr b -> Int -> IO Sint8
$cpokeByteOff :: forall b. Ptr b -> Int -> Sint8 -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> Sint8 -> IO ()
$cpeek :: Ptr Sint8 -> IO Sint8
peek :: Ptr Sint8 -> IO Sint8
$cpoke :: Ptr Sint8 -> Sint8 -> IO ()
poke :: Ptr Sint8 -> Sint8 -> IO ()
BG.Storable
    , Sint8
Sint8 -> Sint8 -> Bounded Sint8
forall a. a -> a -> Bounded a
$cminBound :: Sint8
minBound :: Sint8
$cmaxBound :: Sint8
maxBound :: Sint8
Bounded
    , Int -> Sint8
Sint8 -> Int
Sint8 -> [Sint8]
Sint8 -> Sint8
Sint8 -> Sint8 -> [Sint8]
Sint8 -> Sint8 -> Sint8 -> [Sint8]
(Sint8 -> Sint8)
-> (Sint8 -> Sint8)
-> (Int -> Sint8)
-> (Sint8 -> Int)
-> (Sint8 -> [Sint8])
-> (Sint8 -> Sint8 -> [Sint8])
-> (Sint8 -> Sint8 -> [Sint8])
-> (Sint8 -> Sint8 -> Sint8 -> [Sint8])
-> Enum Sint8
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Sint8 -> Sint8
succ :: Sint8 -> Sint8
$cpred :: Sint8 -> Sint8
pred :: Sint8 -> Sint8
$ctoEnum :: Int -> Sint8
toEnum :: Int -> Sint8
$cfromEnum :: Sint8 -> Int
fromEnum :: Sint8 -> Int
$cenumFrom :: Sint8 -> [Sint8]
enumFrom :: Sint8 -> [Sint8]
$cenumFromThen :: Sint8 -> Sint8 -> [Sint8]
enumFromThen :: Sint8 -> Sint8 -> [Sint8]
$cenumFromTo :: Sint8 -> Sint8 -> [Sint8]
enumFromTo :: Sint8 -> Sint8 -> [Sint8]
$cenumFromThenTo :: Sint8 -> Sint8 -> Sint8 -> [Sint8]
enumFromThenTo :: Sint8 -> Sint8 -> Sint8 -> [Sint8]
Enum
    , Enum Sint8
Real Sint8
(Real Sint8, Enum Sint8) =>
(Sint8 -> Sint8 -> Sint8)
-> (Sint8 -> Sint8 -> Sint8)
-> (Sint8 -> Sint8 -> Sint8)
-> (Sint8 -> Sint8 -> Sint8)
-> (Sint8 -> Sint8 -> (Sint8, Sint8))
-> (Sint8 -> Sint8 -> (Sint8, Sint8))
-> (Sint8 -> Integer)
-> Integral Sint8
Sint8 -> Integer
Sint8 -> Sint8 -> (Sint8, Sint8)
Sint8 -> Sint8 -> Sint8
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
$cquot :: Sint8 -> Sint8 -> Sint8
quot :: Sint8 -> Sint8 -> Sint8
$crem :: Sint8 -> Sint8 -> Sint8
rem :: Sint8 -> Sint8 -> Sint8
$cdiv :: Sint8 -> Sint8 -> Sint8
div :: Sint8 -> Sint8 -> Sint8
$cmod :: Sint8 -> Sint8 -> Sint8
mod :: Sint8 -> Sint8 -> Sint8
$cquotRem :: Sint8 -> Sint8 -> (Sint8, Sint8)
quotRem :: Sint8 -> Sint8 -> (Sint8, Sint8)
$cdivMod :: Sint8 -> Sint8 -> (Sint8, Sint8)
divMod :: Sint8 -> Sint8 -> (Sint8, Sint8)
$ctoInteger :: Sint8 -> Integer
toInteger :: Sint8 -> Integer
Integral
    , Ptr Sint8 -> IO Sint8
(Ptr Sint8 -> IO Sint8) -> ReadRaw Sint8
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr Sint8 -> IO Sint8
readRaw :: Ptr Sint8 -> IO Sint8
Marshal.ReadRaw
    , Proxy Sint8 -> Int
(Proxy Sint8 -> Int) -> (Proxy Sint8 -> Int) -> StaticSize Sint8
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy Sint8 -> Int
staticSizeOf :: Proxy Sint8 -> Int
$cstaticAlignment :: Proxy Sint8 -> Int
staticAlignment :: Proxy Sint8 -> Int
Marshal.StaticSize
    , Ptr Sint8 -> Sint8 -> IO ()
(Ptr Sint8 -> Sint8 -> IO ()) -> WriteRaw Sint8
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr Sint8 -> Sint8 -> IO ()
writeRaw :: Ptr Sint8 -> Sint8 -> IO ()
Marshal.WriteRaw
    , Integer -> Sint8
Sint8 -> Sint8
Sint8 -> Sint8 -> Sint8
(Sint8 -> Sint8 -> Sint8)
-> (Sint8 -> Sint8 -> Sint8)
-> (Sint8 -> Sint8 -> Sint8)
-> (Sint8 -> Sint8)
-> (Sint8 -> Sint8)
-> (Sint8 -> Sint8)
-> (Integer -> Sint8)
-> Num Sint8
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Sint8 -> Sint8 -> Sint8
+ :: Sint8 -> Sint8 -> Sint8
$c- :: Sint8 -> Sint8 -> Sint8
- :: Sint8 -> Sint8 -> Sint8
$c* :: Sint8 -> Sint8 -> Sint8
* :: Sint8 -> Sint8 -> Sint8
$cnegate :: Sint8 -> Sint8
negate :: Sint8 -> Sint8
$cabs :: Sint8 -> Sint8
abs :: Sint8 -> Sint8
$csignum :: Sint8 -> Sint8
signum :: Sint8 -> Sint8
$cfromInteger :: Integer -> Sint8
fromInteger :: Integer -> Sint8
Num
    , Num Sint8
Ord Sint8
(Num Sint8, Ord Sint8) => (Sint8 -> Rational) -> Real Sint8
Sint8 -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Sint8 -> Rational
toRational :: Sint8 -> Rational
Real
    )

instance
  (ty ~ HsBindgen.Runtime.LibC.Int8)
  => BG.CompatHasField.HasField "unwrap" Sint8 ty
  where
  hasField :: Sint8 -> (ty -> Sint8, ty)
hasField =
    \Sint8
x0 ->
      ( \ty
y1 ->
          Sint8{unwrap :: Int8
unwrap = ty
Int8
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" Sint8
x0
      )

instance
  (ty ~ HsBindgen.Runtime.LibC.Int8)
  => BG.HasField "unwrap" (BG.Ptr Sint8) (BG.Ptr ty)
  where
  getField :: Ptr Sint8 -> Ptr ty
getField = Proxy "unwrap" -> Ptr Sint8 -> Ptr (CFieldType Sint8 "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField Sint8 "unwrap" where
  type
    CFieldType Sint8 "unwrap" =
      HsBindgen.Runtime.LibC.Int8

  offset# :: Proxy# Sint8 -> Proxy# "unwrap" -> Int
offset# = \Proxy# Sint8
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | An unsigned 8-bit integer type.
--
--     @since 3.2.0
--
--     [C declaration]: @Uint8@, defined at @SDL3\/SDL_stdinc.h 446:17@
newtype Uint8 = Uint8
  { Uint8 -> Word8
unwrap :: HsBindgen.Runtime.LibC.Word8
  }
  deriving stock ((forall x. Uint8 -> Rep Uint8 x)
-> (forall x. Rep Uint8 x -> Uint8) -> Generic Uint8
forall x. Rep Uint8 x -> Uint8
forall x. Uint8 -> Rep Uint8 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Uint8 -> Rep Uint8 x
from :: forall x. Uint8 -> Rep Uint8 x
$cto :: forall x. Rep Uint8 x -> Uint8
to :: forall x. Rep Uint8 x -> Uint8
BG.Generic, Uint8 -> Uint8 -> Bool
(Uint8 -> Uint8 -> Bool) -> (Uint8 -> Uint8 -> Bool) -> Eq Uint8
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Uint8 -> Uint8 -> Bool
== :: Uint8 -> Uint8 -> Bool
$c/= :: Uint8 -> Uint8 -> Bool
/= :: Uint8 -> Uint8 -> Bool
Eq, Eq Uint8
Eq Uint8 =>
(Uint8 -> Uint8 -> Ordering)
-> (Uint8 -> Uint8 -> Bool)
-> (Uint8 -> Uint8 -> Bool)
-> (Uint8 -> Uint8 -> Bool)
-> (Uint8 -> Uint8 -> Bool)
-> (Uint8 -> Uint8 -> Uint8)
-> (Uint8 -> Uint8 -> Uint8)
-> Ord Uint8
Uint8 -> Uint8 -> Bool
Uint8 -> Uint8 -> Ordering
Uint8 -> Uint8 -> Uint8
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
$ccompare :: Uint8 -> Uint8 -> Ordering
compare :: Uint8 -> Uint8 -> Ordering
$c< :: Uint8 -> Uint8 -> Bool
< :: Uint8 -> Uint8 -> Bool
$c<= :: Uint8 -> Uint8 -> Bool
<= :: Uint8 -> Uint8 -> Bool
$c> :: Uint8 -> Uint8 -> Bool
> :: Uint8 -> Uint8 -> Bool
$c>= :: Uint8 -> Uint8 -> Bool
>= :: Uint8 -> Uint8 -> Bool
$cmax :: Uint8 -> Uint8 -> Uint8
max :: Uint8 -> Uint8 -> Uint8
$cmin :: Uint8 -> Uint8 -> Uint8
min :: Uint8 -> Uint8 -> Uint8
Ord, ReadPrec [Uint8]
ReadPrec Uint8
Int -> ReadS Uint8
ReadS [Uint8]
(Int -> ReadS Uint8)
-> ReadS [Uint8]
-> ReadPrec Uint8
-> ReadPrec [Uint8]
-> Read Uint8
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Uint8
readsPrec :: Int -> ReadS Uint8
$creadList :: ReadS [Uint8]
readList :: ReadS [Uint8]
$creadPrec :: ReadPrec Uint8
readPrec :: ReadPrec Uint8
$creadListPrec :: ReadPrec [Uint8]
readListPrec :: ReadPrec [Uint8]
Read, Int -> Uint8 -> ShowS
[Uint8] -> ShowS
Uint8 -> String
(Int -> Uint8 -> ShowS)
-> (Uint8 -> String) -> ([Uint8] -> ShowS) -> Show Uint8
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Uint8 -> ShowS
showsPrec :: Int -> Uint8 -> ShowS
$cshow :: Uint8 -> String
show :: Uint8 -> String
$cshowList :: [Uint8] -> ShowS
showList :: [Uint8] -> ShowS
Show)
  deriving newtype
    ( Word64 -> Int -> Uint8
Uint8 -> Int -> Word64
(Uint8 -> Int -> Word64)
-> (Word64 -> Int -> Uint8) -> Bitfield Uint8
forall a.
(a -> Int -> Word64) -> (Word64 -> Int -> a) -> Bitfield a
$cnarrow :: Uint8 -> Int -> Word64
narrow :: Uint8 -> Int -> Word64
$cextend :: Word64 -> Int -> Uint8
extend :: Word64 -> Int -> Uint8
BG.Bitfield
    , Eq Uint8
Uint8
Eq Uint8 =>
(Uint8 -> Uint8 -> Uint8)
-> (Uint8 -> Uint8 -> Uint8)
-> (Uint8 -> Uint8 -> Uint8)
-> (Uint8 -> Uint8)
-> (Uint8 -> Int -> Uint8)
-> (Uint8 -> Int -> Uint8)
-> Uint8
-> (Int -> Uint8)
-> (Uint8 -> Int -> Uint8)
-> (Uint8 -> Int -> Uint8)
-> (Uint8 -> Int -> Uint8)
-> (Uint8 -> Int -> Bool)
-> (Uint8 -> Maybe Int)
-> (Uint8 -> Int)
-> (Uint8 -> Bool)
-> (Uint8 -> Int -> Uint8)
-> (Uint8 -> Int -> Uint8)
-> (Uint8 -> Int -> Uint8)
-> (Uint8 -> Int -> Uint8)
-> (Uint8 -> Int -> Uint8)
-> (Uint8 -> Int -> Uint8)
-> (Uint8 -> Int)
-> Bits Uint8
Int -> Uint8
Uint8 -> Bool
Uint8 -> Int
Uint8 -> Maybe Int
Uint8 -> Uint8
Uint8 -> Int -> Bool
Uint8 -> Int -> Uint8
Uint8 -> Uint8 -> Uint8
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
$c.&. :: Uint8 -> Uint8 -> Uint8
.&. :: Uint8 -> Uint8 -> Uint8
$c.|. :: Uint8 -> Uint8 -> Uint8
.|. :: Uint8 -> Uint8 -> Uint8
$cxor :: Uint8 -> Uint8 -> Uint8
xor :: Uint8 -> Uint8 -> Uint8
$ccomplement :: Uint8 -> Uint8
complement :: Uint8 -> Uint8
$cshift :: Uint8 -> Int -> Uint8
shift :: Uint8 -> Int -> Uint8
$crotate :: Uint8 -> Int -> Uint8
rotate :: Uint8 -> Int -> Uint8
$czeroBits :: Uint8
zeroBits :: Uint8
$cbit :: Int -> Uint8
bit :: Int -> Uint8
$csetBit :: Uint8 -> Int -> Uint8
setBit :: Uint8 -> Int -> Uint8
$cclearBit :: Uint8 -> Int -> Uint8
clearBit :: Uint8 -> Int -> Uint8
$ccomplementBit :: Uint8 -> Int -> Uint8
complementBit :: Uint8 -> Int -> Uint8
$ctestBit :: Uint8 -> Int -> Bool
testBit :: Uint8 -> Int -> Bool
$cbitSizeMaybe :: Uint8 -> Maybe Int
bitSizeMaybe :: Uint8 -> Maybe Int
$cbitSize :: Uint8 -> Int
bitSize :: Uint8 -> Int
$cisSigned :: Uint8 -> Bool
isSigned :: Uint8 -> Bool
$cshiftL :: Uint8 -> Int -> Uint8
shiftL :: Uint8 -> Int -> Uint8
$cunsafeShiftL :: Uint8 -> Int -> Uint8
unsafeShiftL :: Uint8 -> Int -> Uint8
$cshiftR :: Uint8 -> Int -> Uint8
shiftR :: Uint8 -> Int -> Uint8
$cunsafeShiftR :: Uint8 -> Int -> Uint8
unsafeShiftR :: Uint8 -> Int -> Uint8
$crotateL :: Uint8 -> Int -> Uint8
rotateL :: Uint8 -> Int -> Uint8
$crotateR :: Uint8 -> Int -> Uint8
rotateR :: Uint8 -> Int -> Uint8
$cpopCount :: Uint8 -> Int
popCount :: Uint8 -> Int
BG.Bits
    , Bits Uint8
Bits Uint8 =>
(Uint8 -> Int)
-> (Uint8 -> Int) -> (Uint8 -> Int) -> FiniteBits Uint8
Uint8 -> Int
forall b.
Bits b =>
(b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
$cfiniteBitSize :: Uint8 -> Int
finiteBitSize :: Uint8 -> Int
$ccountLeadingZeros :: Uint8 -> Int
countLeadingZeros :: Uint8 -> Int
$ccountTrailingZeros :: Uint8 -> Int
countTrailingZeros :: Uint8 -> Int
BG.FiniteBits
    , FFIType Uint8 -> Uint8
Uint8 -> FFIType Uint8
(Uint8 -> FFIType Uint8)
-> (FFIType Uint8 -> Uint8) -> HasFFIType Uint8
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: Uint8 -> FFIType Uint8
toFFIType :: Uint8 -> FFIType Uint8
$cfromFFIType :: FFIType Uint8 -> Uint8
fromFFIType :: FFIType Uint8 -> Uint8
BG.HasFFIType
    , Ord Uint8
Ord Uint8 =>
((Uint8, Uint8) -> [Uint8])
-> ((Uint8, Uint8) -> Uint8 -> Int)
-> ((Uint8, Uint8) -> Uint8 -> Int)
-> ((Uint8, Uint8) -> Uint8 -> Bool)
-> ((Uint8, Uint8) -> Int)
-> ((Uint8, Uint8) -> Int)
-> Ix Uint8
(Uint8, Uint8) -> Int
(Uint8, Uint8) -> [Uint8]
(Uint8, Uint8) -> Uint8 -> Bool
(Uint8, Uint8) -> Uint8 -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
$crange :: (Uint8, Uint8) -> [Uint8]
range :: (Uint8, Uint8) -> [Uint8]
$cindex :: (Uint8, Uint8) -> Uint8 -> Int
index :: (Uint8, Uint8) -> Uint8 -> Int
$cunsafeIndex :: (Uint8, Uint8) -> Uint8 -> Int
unsafeIndex :: (Uint8, Uint8) -> Uint8 -> Int
$cinRange :: (Uint8, Uint8) -> Uint8 -> Bool
inRange :: (Uint8, Uint8) -> Uint8 -> Bool
$crangeSize :: (Uint8, Uint8) -> Int
rangeSize :: (Uint8, Uint8) -> Int
$cunsafeRangeSize :: (Uint8, Uint8) -> Int
unsafeRangeSize :: (Uint8, Uint8) -> Int
BG.Ix
    , Addr# -> Int# -> Uint8
ByteArray# -> Int# -> Uint8
Proxy Uint8 -> Int#
Uint8 -> Int#
(Proxy Uint8 -> Int#)
-> (Uint8 -> Int#)
-> (Proxy Uint8 -> Int#)
-> (Uint8 -> Int#)
-> (ByteArray# -> Int# -> Uint8)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint8 #))
-> (forall s.
    MutableByteArray# s -> Int# -> Uint8 -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s
    -> Int# -> Int# -> Uint8 -> State# s -> State# s)
-> (Addr# -> Int# -> Uint8)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, Uint8 #))
-> (forall s. Addr# -> Int# -> Uint8 -> State# s -> State# s)
-> (forall s.
    Addr# -> Int# -> Int# -> Uint8 -> State# s -> State# s)
-> Prim Uint8
forall s. Addr# -> Int# -> Int# -> Uint8 -> State# s -> State# s
forall s. Addr# -> Int# -> State# s -> (# State# s, Uint8 #)
forall s. Addr# -> Int# -> Uint8 -> State# s -> State# s
forall s.
MutableByteArray# s
-> Int# -> Int# -> Uint8 -> State# s -> State# s
forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint8 #)
forall s.
MutableByteArray# s -> Int# -> Uint8 -> State# s -> State# s
forall a.
(Proxy a -> Int#)
-> (a -> Int#)
-> (Proxy a -> Int#)
-> (a -> Int#)
-> (ByteArray# -> Int# -> a)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, a #))
-> (forall s.
    MutableByteArray# s -> Int# -> a -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s)
-> (Addr# -> Int# -> a)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, a #))
-> (forall s. Addr# -> Int# -> a -> State# s -> State# s)
-> (forall s. Addr# -> Int# -> Int# -> a -> State# s -> State# s)
-> Prim a
$csizeOfType# :: Proxy Uint8 -> Int#
sizeOfType# :: Proxy Uint8 -> Int#
$csizeOf# :: Uint8 -> Int#
sizeOf# :: Uint8 -> Int#
$calignmentOfType# :: Proxy Uint8 -> Int#
alignmentOfType# :: Proxy Uint8 -> Int#
$calignment# :: Uint8 -> Int#
alignment# :: Uint8 -> Int#
$cindexByteArray# :: ByteArray# -> Int# -> Uint8
indexByteArray# :: ByteArray# -> Int# -> Uint8
$creadByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint8 #)
readByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint8 #)
$cwriteByteArray# :: forall s.
MutableByteArray# s -> Int# -> Uint8 -> State# s -> State# s
writeByteArray# :: forall s.
MutableByteArray# s -> Int# -> Uint8 -> State# s -> State# s
$csetByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Uint8 -> State# s -> State# s
setByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Uint8 -> State# s -> State# s
$cindexOffAddr# :: Addr# -> Int# -> Uint8
indexOffAddr# :: Addr# -> Int# -> Uint8
$creadOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Uint8 #)
readOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Uint8 #)
$cwriteOffAddr# :: forall s. Addr# -> Int# -> Uint8 -> State# s -> State# s
writeOffAddr# :: forall s. Addr# -> Int# -> Uint8 -> State# s -> State# s
$csetOffAddr# :: forall s. Addr# -> Int# -> Int# -> Uint8 -> State# s -> State# s
setOffAddr# :: forall s. Addr# -> Int# -> Int# -> Uint8 -> State# s -> State# s
BG.Prim
    , Ptr Uint8 -> IO Uint8
Ptr Uint8 -> Int -> IO Uint8
Ptr Uint8 -> Int -> Uint8 -> IO ()
Ptr Uint8 -> Uint8 -> IO ()
Uint8 -> Int
(Uint8 -> Int)
-> (Uint8 -> Int)
-> (Ptr Uint8 -> Int -> IO Uint8)
-> (Ptr Uint8 -> Int -> Uint8 -> IO ())
-> (forall b. Ptr b -> Int -> IO Uint8)
-> (forall b. Ptr b -> Int -> Uint8 -> IO ())
-> (Ptr Uint8 -> IO Uint8)
-> (Ptr Uint8 -> Uint8 -> IO ())
-> Storable Uint8
forall b. Ptr b -> Int -> IO Uint8
forall b. Ptr b -> Int -> Uint8 -> 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
$csizeOf :: Uint8 -> Int
sizeOf :: Uint8 -> Int
$calignment :: Uint8 -> Int
alignment :: Uint8 -> Int
$cpeekElemOff :: Ptr Uint8 -> Int -> IO Uint8
peekElemOff :: Ptr Uint8 -> Int -> IO Uint8
$cpokeElemOff :: Ptr Uint8 -> Int -> Uint8 -> IO ()
pokeElemOff :: Ptr Uint8 -> Int -> Uint8 -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Uint8
peekByteOff :: forall b. Ptr b -> Int -> IO Uint8
$cpokeByteOff :: forall b. Ptr b -> Int -> Uint8 -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> Uint8 -> IO ()
$cpeek :: Ptr Uint8 -> IO Uint8
peek :: Ptr Uint8 -> IO Uint8
$cpoke :: Ptr Uint8 -> Uint8 -> IO ()
poke :: Ptr Uint8 -> Uint8 -> IO ()
BG.Storable
    , Uint8
Uint8 -> Uint8 -> Bounded Uint8
forall a. a -> a -> Bounded a
$cminBound :: Uint8
minBound :: Uint8
$cmaxBound :: Uint8
maxBound :: Uint8
Bounded
    , Int -> Uint8
Uint8 -> Int
Uint8 -> [Uint8]
Uint8 -> Uint8
Uint8 -> Uint8 -> [Uint8]
Uint8 -> Uint8 -> Uint8 -> [Uint8]
(Uint8 -> Uint8)
-> (Uint8 -> Uint8)
-> (Int -> Uint8)
-> (Uint8 -> Int)
-> (Uint8 -> [Uint8])
-> (Uint8 -> Uint8 -> [Uint8])
-> (Uint8 -> Uint8 -> [Uint8])
-> (Uint8 -> Uint8 -> Uint8 -> [Uint8])
-> Enum Uint8
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Uint8 -> Uint8
succ :: Uint8 -> Uint8
$cpred :: Uint8 -> Uint8
pred :: Uint8 -> Uint8
$ctoEnum :: Int -> Uint8
toEnum :: Int -> Uint8
$cfromEnum :: Uint8 -> Int
fromEnum :: Uint8 -> Int
$cenumFrom :: Uint8 -> [Uint8]
enumFrom :: Uint8 -> [Uint8]
$cenumFromThen :: Uint8 -> Uint8 -> [Uint8]
enumFromThen :: Uint8 -> Uint8 -> [Uint8]
$cenumFromTo :: Uint8 -> Uint8 -> [Uint8]
enumFromTo :: Uint8 -> Uint8 -> [Uint8]
$cenumFromThenTo :: Uint8 -> Uint8 -> Uint8 -> [Uint8]
enumFromThenTo :: Uint8 -> Uint8 -> Uint8 -> [Uint8]
Enum
    , Enum Uint8
Real Uint8
(Real Uint8, Enum Uint8) =>
(Uint8 -> Uint8 -> Uint8)
-> (Uint8 -> Uint8 -> Uint8)
-> (Uint8 -> Uint8 -> Uint8)
-> (Uint8 -> Uint8 -> Uint8)
-> (Uint8 -> Uint8 -> (Uint8, Uint8))
-> (Uint8 -> Uint8 -> (Uint8, Uint8))
-> (Uint8 -> Integer)
-> Integral Uint8
Uint8 -> Integer
Uint8 -> Uint8 -> (Uint8, Uint8)
Uint8 -> Uint8 -> Uint8
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
$cquot :: Uint8 -> Uint8 -> Uint8
quot :: Uint8 -> Uint8 -> Uint8
$crem :: Uint8 -> Uint8 -> Uint8
rem :: Uint8 -> Uint8 -> Uint8
$cdiv :: Uint8 -> Uint8 -> Uint8
div :: Uint8 -> Uint8 -> Uint8
$cmod :: Uint8 -> Uint8 -> Uint8
mod :: Uint8 -> Uint8 -> Uint8
$cquotRem :: Uint8 -> Uint8 -> (Uint8, Uint8)
quotRem :: Uint8 -> Uint8 -> (Uint8, Uint8)
$cdivMod :: Uint8 -> Uint8 -> (Uint8, Uint8)
divMod :: Uint8 -> Uint8 -> (Uint8, Uint8)
$ctoInteger :: Uint8 -> Integer
toInteger :: Uint8 -> Integer
Integral
    , Ptr Uint8 -> IO Uint8
(Ptr Uint8 -> IO Uint8) -> ReadRaw Uint8
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr Uint8 -> IO Uint8
readRaw :: Ptr Uint8 -> IO Uint8
Marshal.ReadRaw
    , Proxy Uint8 -> Int
(Proxy Uint8 -> Int) -> (Proxy Uint8 -> Int) -> StaticSize Uint8
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy Uint8 -> Int
staticSizeOf :: Proxy Uint8 -> Int
$cstaticAlignment :: Proxy Uint8 -> Int
staticAlignment :: Proxy Uint8 -> Int
Marshal.StaticSize
    , Ptr Uint8 -> Uint8 -> IO ()
(Ptr Uint8 -> Uint8 -> IO ()) -> WriteRaw Uint8
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr Uint8 -> Uint8 -> IO ()
writeRaw :: Ptr Uint8 -> Uint8 -> IO ()
Marshal.WriteRaw
    , Integer -> Uint8
Uint8 -> Uint8
Uint8 -> Uint8 -> Uint8
(Uint8 -> Uint8 -> Uint8)
-> (Uint8 -> Uint8 -> Uint8)
-> (Uint8 -> Uint8 -> Uint8)
-> (Uint8 -> Uint8)
-> (Uint8 -> Uint8)
-> (Uint8 -> Uint8)
-> (Integer -> Uint8)
-> Num Uint8
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Uint8 -> Uint8 -> Uint8
+ :: Uint8 -> Uint8 -> Uint8
$c- :: Uint8 -> Uint8 -> Uint8
- :: Uint8 -> Uint8 -> Uint8
$c* :: Uint8 -> Uint8 -> Uint8
* :: Uint8 -> Uint8 -> Uint8
$cnegate :: Uint8 -> Uint8
negate :: Uint8 -> Uint8
$cabs :: Uint8 -> Uint8
abs :: Uint8 -> Uint8
$csignum :: Uint8 -> Uint8
signum :: Uint8 -> Uint8
$cfromInteger :: Integer -> Uint8
fromInteger :: Integer -> Uint8
Num
    , Num Uint8
Ord Uint8
(Num Uint8, Ord Uint8) => (Uint8 -> Rational) -> Real Uint8
Uint8 -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Uint8 -> Rational
toRational :: Uint8 -> Rational
Real
    )

instance
  (ty ~ HsBindgen.Runtime.LibC.Word8)
  => BG.CompatHasField.HasField "unwrap" Uint8 ty
  where
  hasField :: Uint8 -> (ty -> Uint8, ty)
hasField =
    \Uint8
x0 ->
      ( \ty
y1 ->
          Uint8{unwrap :: Word8
unwrap = ty
Word8
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" Uint8
x0
      )

instance
  (ty ~ HsBindgen.Runtime.LibC.Word8)
  => BG.HasField "unwrap" (BG.Ptr Uint8) (BG.Ptr ty)
  where
  getField :: Ptr Uint8 -> Ptr ty
getField = Proxy "unwrap" -> Ptr Uint8 -> Ptr (CFieldType Uint8 "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField Uint8 "unwrap" where
  type
    CFieldType Uint8 "unwrap" =
      HsBindgen.Runtime.LibC.Word8

  offset# :: Proxy# Uint8 -> Proxy# "unwrap" -> Int
offset# = \Proxy# Uint8
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | A signed 16-bit integer type.
--
--     @since 3.2.0
--
--     [C declaration]: @Sint16@, defined at @SDL3\/SDL_stdinc.h 455:17@
newtype Sint16 = Sint16
  { Sint16 -> Int16
unwrap :: HsBindgen.Runtime.LibC.Int16
  }
  deriving stock ((forall x. Sint16 -> Rep Sint16 x)
-> (forall x. Rep Sint16 x -> Sint16) -> Generic Sint16
forall x. Rep Sint16 x -> Sint16
forall x. Sint16 -> Rep Sint16 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Sint16 -> Rep Sint16 x
from :: forall x. Sint16 -> Rep Sint16 x
$cto :: forall x. Rep Sint16 x -> Sint16
to :: forall x. Rep Sint16 x -> Sint16
BG.Generic, Sint16 -> Sint16 -> Bool
(Sint16 -> Sint16 -> Bool)
-> (Sint16 -> Sint16 -> Bool) -> Eq Sint16
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Sint16 -> Sint16 -> Bool
== :: Sint16 -> Sint16 -> Bool
$c/= :: Sint16 -> Sint16 -> Bool
/= :: Sint16 -> Sint16 -> Bool
Eq, Eq Sint16
Eq Sint16 =>
(Sint16 -> Sint16 -> Ordering)
-> (Sint16 -> Sint16 -> Bool)
-> (Sint16 -> Sint16 -> Bool)
-> (Sint16 -> Sint16 -> Bool)
-> (Sint16 -> Sint16 -> Bool)
-> (Sint16 -> Sint16 -> Sint16)
-> (Sint16 -> Sint16 -> Sint16)
-> Ord Sint16
Sint16 -> Sint16 -> Bool
Sint16 -> Sint16 -> Ordering
Sint16 -> Sint16 -> Sint16
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
$ccompare :: Sint16 -> Sint16 -> Ordering
compare :: Sint16 -> Sint16 -> Ordering
$c< :: Sint16 -> Sint16 -> Bool
< :: Sint16 -> Sint16 -> Bool
$c<= :: Sint16 -> Sint16 -> Bool
<= :: Sint16 -> Sint16 -> Bool
$c> :: Sint16 -> Sint16 -> Bool
> :: Sint16 -> Sint16 -> Bool
$c>= :: Sint16 -> Sint16 -> Bool
>= :: Sint16 -> Sint16 -> Bool
$cmax :: Sint16 -> Sint16 -> Sint16
max :: Sint16 -> Sint16 -> Sint16
$cmin :: Sint16 -> Sint16 -> Sint16
min :: Sint16 -> Sint16 -> Sint16
Ord, ReadPrec [Sint16]
ReadPrec Sint16
Int -> ReadS Sint16
ReadS [Sint16]
(Int -> ReadS Sint16)
-> ReadS [Sint16]
-> ReadPrec Sint16
-> ReadPrec [Sint16]
-> Read Sint16
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Sint16
readsPrec :: Int -> ReadS Sint16
$creadList :: ReadS [Sint16]
readList :: ReadS [Sint16]
$creadPrec :: ReadPrec Sint16
readPrec :: ReadPrec Sint16
$creadListPrec :: ReadPrec [Sint16]
readListPrec :: ReadPrec [Sint16]
Read, Int -> Sint16 -> ShowS
[Sint16] -> ShowS
Sint16 -> String
(Int -> Sint16 -> ShowS)
-> (Sint16 -> String) -> ([Sint16] -> ShowS) -> Show Sint16
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Sint16 -> ShowS
showsPrec :: Int -> Sint16 -> ShowS
$cshow :: Sint16 -> String
show :: Sint16 -> String
$cshowList :: [Sint16] -> ShowS
showList :: [Sint16] -> ShowS
Show)
  deriving newtype
    ( Word64 -> Int -> Sint16
Sint16 -> Int -> Word64
(Sint16 -> Int -> Word64)
-> (Word64 -> Int -> Sint16) -> Bitfield Sint16
forall a.
(a -> Int -> Word64) -> (Word64 -> Int -> a) -> Bitfield a
$cnarrow :: Sint16 -> Int -> Word64
narrow :: Sint16 -> Int -> Word64
$cextend :: Word64 -> Int -> Sint16
extend :: Word64 -> Int -> Sint16
BG.Bitfield
    , Eq Sint16
Sint16
Eq Sint16 =>
(Sint16 -> Sint16 -> Sint16)
-> (Sint16 -> Sint16 -> Sint16)
-> (Sint16 -> Sint16 -> Sint16)
-> (Sint16 -> Sint16)
-> (Sint16 -> Int -> Sint16)
-> (Sint16 -> Int -> Sint16)
-> Sint16
-> (Int -> Sint16)
-> (Sint16 -> Int -> Sint16)
-> (Sint16 -> Int -> Sint16)
-> (Sint16 -> Int -> Sint16)
-> (Sint16 -> Int -> Bool)
-> (Sint16 -> Maybe Int)
-> (Sint16 -> Int)
-> (Sint16 -> Bool)
-> (Sint16 -> Int -> Sint16)
-> (Sint16 -> Int -> Sint16)
-> (Sint16 -> Int -> Sint16)
-> (Sint16 -> Int -> Sint16)
-> (Sint16 -> Int -> Sint16)
-> (Sint16 -> Int -> Sint16)
-> (Sint16 -> Int)
-> Bits Sint16
Int -> Sint16
Sint16 -> Bool
Sint16 -> Int
Sint16 -> Maybe Int
Sint16 -> Sint16
Sint16 -> Int -> Bool
Sint16 -> Int -> Sint16
Sint16 -> Sint16 -> Sint16
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
$c.&. :: Sint16 -> Sint16 -> Sint16
.&. :: Sint16 -> Sint16 -> Sint16
$c.|. :: Sint16 -> Sint16 -> Sint16
.|. :: Sint16 -> Sint16 -> Sint16
$cxor :: Sint16 -> Sint16 -> Sint16
xor :: Sint16 -> Sint16 -> Sint16
$ccomplement :: Sint16 -> Sint16
complement :: Sint16 -> Sint16
$cshift :: Sint16 -> Int -> Sint16
shift :: Sint16 -> Int -> Sint16
$crotate :: Sint16 -> Int -> Sint16
rotate :: Sint16 -> Int -> Sint16
$czeroBits :: Sint16
zeroBits :: Sint16
$cbit :: Int -> Sint16
bit :: Int -> Sint16
$csetBit :: Sint16 -> Int -> Sint16
setBit :: Sint16 -> Int -> Sint16
$cclearBit :: Sint16 -> Int -> Sint16
clearBit :: Sint16 -> Int -> Sint16
$ccomplementBit :: Sint16 -> Int -> Sint16
complementBit :: Sint16 -> Int -> Sint16
$ctestBit :: Sint16 -> Int -> Bool
testBit :: Sint16 -> Int -> Bool
$cbitSizeMaybe :: Sint16 -> Maybe Int
bitSizeMaybe :: Sint16 -> Maybe Int
$cbitSize :: Sint16 -> Int
bitSize :: Sint16 -> Int
$cisSigned :: Sint16 -> Bool
isSigned :: Sint16 -> Bool
$cshiftL :: Sint16 -> Int -> Sint16
shiftL :: Sint16 -> Int -> Sint16
$cunsafeShiftL :: Sint16 -> Int -> Sint16
unsafeShiftL :: Sint16 -> Int -> Sint16
$cshiftR :: Sint16 -> Int -> Sint16
shiftR :: Sint16 -> Int -> Sint16
$cunsafeShiftR :: Sint16 -> Int -> Sint16
unsafeShiftR :: Sint16 -> Int -> Sint16
$crotateL :: Sint16 -> Int -> Sint16
rotateL :: Sint16 -> Int -> Sint16
$crotateR :: Sint16 -> Int -> Sint16
rotateR :: Sint16 -> Int -> Sint16
$cpopCount :: Sint16 -> Int
popCount :: Sint16 -> Int
BG.Bits
    , Bits Sint16
Bits Sint16 =>
(Sint16 -> Int)
-> (Sint16 -> Int) -> (Sint16 -> Int) -> FiniteBits Sint16
Sint16 -> Int
forall b.
Bits b =>
(b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
$cfiniteBitSize :: Sint16 -> Int
finiteBitSize :: Sint16 -> Int
$ccountLeadingZeros :: Sint16 -> Int
countLeadingZeros :: Sint16 -> Int
$ccountTrailingZeros :: Sint16 -> Int
countTrailingZeros :: Sint16 -> Int
BG.FiniteBits
    , FFIType Sint16 -> Sint16
Sint16 -> FFIType Sint16
(Sint16 -> FFIType Sint16)
-> (FFIType Sint16 -> Sint16) -> HasFFIType Sint16
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: Sint16 -> FFIType Sint16
toFFIType :: Sint16 -> FFIType Sint16
$cfromFFIType :: FFIType Sint16 -> Sint16
fromFFIType :: FFIType Sint16 -> Sint16
BG.HasFFIType
    , Ord Sint16
Ord Sint16 =>
((Sint16, Sint16) -> [Sint16])
-> ((Sint16, Sint16) -> Sint16 -> Int)
-> ((Sint16, Sint16) -> Sint16 -> Int)
-> ((Sint16, Sint16) -> Sint16 -> Bool)
-> ((Sint16, Sint16) -> Int)
-> ((Sint16, Sint16) -> Int)
-> Ix Sint16
(Sint16, Sint16) -> Int
(Sint16, Sint16) -> [Sint16]
(Sint16, Sint16) -> Sint16 -> Bool
(Sint16, Sint16) -> Sint16 -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
$crange :: (Sint16, Sint16) -> [Sint16]
range :: (Sint16, Sint16) -> [Sint16]
$cindex :: (Sint16, Sint16) -> Sint16 -> Int
index :: (Sint16, Sint16) -> Sint16 -> Int
$cunsafeIndex :: (Sint16, Sint16) -> Sint16 -> Int
unsafeIndex :: (Sint16, Sint16) -> Sint16 -> Int
$cinRange :: (Sint16, Sint16) -> Sint16 -> Bool
inRange :: (Sint16, Sint16) -> Sint16 -> Bool
$crangeSize :: (Sint16, Sint16) -> Int
rangeSize :: (Sint16, Sint16) -> Int
$cunsafeRangeSize :: (Sint16, Sint16) -> Int
unsafeRangeSize :: (Sint16, Sint16) -> Int
BG.Ix
    , Addr# -> Int# -> Sint16
ByteArray# -> Int# -> Sint16
Proxy Sint16 -> Int#
Sint16 -> Int#
(Proxy Sint16 -> Int#)
-> (Sint16 -> Int#)
-> (Proxy Sint16 -> Int#)
-> (Sint16 -> Int#)
-> (ByteArray# -> Int# -> Sint16)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint16 #))
-> (forall s.
    MutableByteArray# s -> Int# -> Sint16 -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s
    -> Int# -> Int# -> Sint16 -> State# s -> State# s)
-> (Addr# -> Int# -> Sint16)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, Sint16 #))
-> (forall s. Addr# -> Int# -> Sint16 -> State# s -> State# s)
-> (forall s.
    Addr# -> Int# -> Int# -> Sint16 -> State# s -> State# s)
-> Prim Sint16
forall s. Addr# -> Int# -> Int# -> Sint16 -> State# s -> State# s
forall s. Addr# -> Int# -> State# s -> (# State# s, Sint16 #)
forall s. Addr# -> Int# -> Sint16 -> State# s -> State# s
forall s.
MutableByteArray# s
-> Int# -> Int# -> Sint16 -> State# s -> State# s
forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint16 #)
forall s.
MutableByteArray# s -> Int# -> Sint16 -> State# s -> State# s
forall a.
(Proxy a -> Int#)
-> (a -> Int#)
-> (Proxy a -> Int#)
-> (a -> Int#)
-> (ByteArray# -> Int# -> a)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, a #))
-> (forall s.
    MutableByteArray# s -> Int# -> a -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s)
-> (Addr# -> Int# -> a)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, a #))
-> (forall s. Addr# -> Int# -> a -> State# s -> State# s)
-> (forall s. Addr# -> Int# -> Int# -> a -> State# s -> State# s)
-> Prim a
$csizeOfType# :: Proxy Sint16 -> Int#
sizeOfType# :: Proxy Sint16 -> Int#
$csizeOf# :: Sint16 -> Int#
sizeOf# :: Sint16 -> Int#
$calignmentOfType# :: Proxy Sint16 -> Int#
alignmentOfType# :: Proxy Sint16 -> Int#
$calignment# :: Sint16 -> Int#
alignment# :: Sint16 -> Int#
$cindexByteArray# :: ByteArray# -> Int# -> Sint16
indexByteArray# :: ByteArray# -> Int# -> Sint16
$creadByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint16 #)
readByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint16 #)
$cwriteByteArray# :: forall s.
MutableByteArray# s -> Int# -> Sint16 -> State# s -> State# s
writeByteArray# :: forall s.
MutableByteArray# s -> Int# -> Sint16 -> State# s -> State# s
$csetByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Sint16 -> State# s -> State# s
setByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Sint16 -> State# s -> State# s
$cindexOffAddr# :: Addr# -> Int# -> Sint16
indexOffAddr# :: Addr# -> Int# -> Sint16
$creadOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Sint16 #)
readOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Sint16 #)
$cwriteOffAddr# :: forall s. Addr# -> Int# -> Sint16 -> State# s -> State# s
writeOffAddr# :: forall s. Addr# -> Int# -> Sint16 -> State# s -> State# s
$csetOffAddr# :: forall s. Addr# -> Int# -> Int# -> Sint16 -> State# s -> State# s
setOffAddr# :: forall s. Addr# -> Int# -> Int# -> Sint16 -> State# s -> State# s
BG.Prim
    , Ptr Sint16 -> IO Sint16
Ptr Sint16 -> Int -> IO Sint16
Ptr Sint16 -> Int -> Sint16 -> IO ()
Ptr Sint16 -> Sint16 -> IO ()
Sint16 -> Int
(Sint16 -> Int)
-> (Sint16 -> Int)
-> (Ptr Sint16 -> Int -> IO Sint16)
-> (Ptr Sint16 -> Int -> Sint16 -> IO ())
-> (forall b. Ptr b -> Int -> IO Sint16)
-> (forall b. Ptr b -> Int -> Sint16 -> IO ())
-> (Ptr Sint16 -> IO Sint16)
-> (Ptr Sint16 -> Sint16 -> IO ())
-> Storable Sint16
forall b. Ptr b -> Int -> IO Sint16
forall b. Ptr b -> Int -> Sint16 -> 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
$csizeOf :: Sint16 -> Int
sizeOf :: Sint16 -> Int
$calignment :: Sint16 -> Int
alignment :: Sint16 -> Int
$cpeekElemOff :: Ptr Sint16 -> Int -> IO Sint16
peekElemOff :: Ptr Sint16 -> Int -> IO Sint16
$cpokeElemOff :: Ptr Sint16 -> Int -> Sint16 -> IO ()
pokeElemOff :: Ptr Sint16 -> Int -> Sint16 -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Sint16
peekByteOff :: forall b. Ptr b -> Int -> IO Sint16
$cpokeByteOff :: forall b. Ptr b -> Int -> Sint16 -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> Sint16 -> IO ()
$cpeek :: Ptr Sint16 -> IO Sint16
peek :: Ptr Sint16 -> IO Sint16
$cpoke :: Ptr Sint16 -> Sint16 -> IO ()
poke :: Ptr Sint16 -> Sint16 -> IO ()
BG.Storable
    , Sint16
Sint16 -> Sint16 -> Bounded Sint16
forall a. a -> a -> Bounded a
$cminBound :: Sint16
minBound :: Sint16
$cmaxBound :: Sint16
maxBound :: Sint16
Bounded
    , Int -> Sint16
Sint16 -> Int
Sint16 -> [Sint16]
Sint16 -> Sint16
Sint16 -> Sint16 -> [Sint16]
Sint16 -> Sint16 -> Sint16 -> [Sint16]
(Sint16 -> Sint16)
-> (Sint16 -> Sint16)
-> (Int -> Sint16)
-> (Sint16 -> Int)
-> (Sint16 -> [Sint16])
-> (Sint16 -> Sint16 -> [Sint16])
-> (Sint16 -> Sint16 -> [Sint16])
-> (Sint16 -> Sint16 -> Sint16 -> [Sint16])
-> Enum Sint16
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Sint16 -> Sint16
succ :: Sint16 -> Sint16
$cpred :: Sint16 -> Sint16
pred :: Sint16 -> Sint16
$ctoEnum :: Int -> Sint16
toEnum :: Int -> Sint16
$cfromEnum :: Sint16 -> Int
fromEnum :: Sint16 -> Int
$cenumFrom :: Sint16 -> [Sint16]
enumFrom :: Sint16 -> [Sint16]
$cenumFromThen :: Sint16 -> Sint16 -> [Sint16]
enumFromThen :: Sint16 -> Sint16 -> [Sint16]
$cenumFromTo :: Sint16 -> Sint16 -> [Sint16]
enumFromTo :: Sint16 -> Sint16 -> [Sint16]
$cenumFromThenTo :: Sint16 -> Sint16 -> Sint16 -> [Sint16]
enumFromThenTo :: Sint16 -> Sint16 -> Sint16 -> [Sint16]
Enum
    , Enum Sint16
Real Sint16
(Real Sint16, Enum Sint16) =>
(Sint16 -> Sint16 -> Sint16)
-> (Sint16 -> Sint16 -> Sint16)
-> (Sint16 -> Sint16 -> Sint16)
-> (Sint16 -> Sint16 -> Sint16)
-> (Sint16 -> Sint16 -> (Sint16, Sint16))
-> (Sint16 -> Sint16 -> (Sint16, Sint16))
-> (Sint16 -> Integer)
-> Integral Sint16
Sint16 -> Integer
Sint16 -> Sint16 -> (Sint16, Sint16)
Sint16 -> Sint16 -> Sint16
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
$cquot :: Sint16 -> Sint16 -> Sint16
quot :: Sint16 -> Sint16 -> Sint16
$crem :: Sint16 -> Sint16 -> Sint16
rem :: Sint16 -> Sint16 -> Sint16
$cdiv :: Sint16 -> Sint16 -> Sint16
div :: Sint16 -> Sint16 -> Sint16
$cmod :: Sint16 -> Sint16 -> Sint16
mod :: Sint16 -> Sint16 -> Sint16
$cquotRem :: Sint16 -> Sint16 -> (Sint16, Sint16)
quotRem :: Sint16 -> Sint16 -> (Sint16, Sint16)
$cdivMod :: Sint16 -> Sint16 -> (Sint16, Sint16)
divMod :: Sint16 -> Sint16 -> (Sint16, Sint16)
$ctoInteger :: Sint16 -> Integer
toInteger :: Sint16 -> Integer
Integral
    , Ptr Sint16 -> IO Sint16
(Ptr Sint16 -> IO Sint16) -> ReadRaw Sint16
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr Sint16 -> IO Sint16
readRaw :: Ptr Sint16 -> IO Sint16
Marshal.ReadRaw
    , Proxy Sint16 -> Int
(Proxy Sint16 -> Int) -> (Proxy Sint16 -> Int) -> StaticSize Sint16
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy Sint16 -> Int
staticSizeOf :: Proxy Sint16 -> Int
$cstaticAlignment :: Proxy Sint16 -> Int
staticAlignment :: Proxy Sint16 -> Int
Marshal.StaticSize
    , Ptr Sint16 -> Sint16 -> IO ()
(Ptr Sint16 -> Sint16 -> IO ()) -> WriteRaw Sint16
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr Sint16 -> Sint16 -> IO ()
writeRaw :: Ptr Sint16 -> Sint16 -> IO ()
Marshal.WriteRaw
    , Integer -> Sint16
Sint16 -> Sint16
Sint16 -> Sint16 -> Sint16
(Sint16 -> Sint16 -> Sint16)
-> (Sint16 -> Sint16 -> Sint16)
-> (Sint16 -> Sint16 -> Sint16)
-> (Sint16 -> Sint16)
-> (Sint16 -> Sint16)
-> (Sint16 -> Sint16)
-> (Integer -> Sint16)
-> Num Sint16
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Sint16 -> Sint16 -> Sint16
+ :: Sint16 -> Sint16 -> Sint16
$c- :: Sint16 -> Sint16 -> Sint16
- :: Sint16 -> Sint16 -> Sint16
$c* :: Sint16 -> Sint16 -> Sint16
* :: Sint16 -> Sint16 -> Sint16
$cnegate :: Sint16 -> Sint16
negate :: Sint16 -> Sint16
$cabs :: Sint16 -> Sint16
abs :: Sint16 -> Sint16
$csignum :: Sint16 -> Sint16
signum :: Sint16 -> Sint16
$cfromInteger :: Integer -> Sint16
fromInteger :: Integer -> Sint16
Num
    , Num Sint16
Ord Sint16
(Num Sint16, Ord Sint16) => (Sint16 -> Rational) -> Real Sint16
Sint16 -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Sint16 -> Rational
toRational :: Sint16 -> Rational
Real
    )

instance
  (ty ~ HsBindgen.Runtime.LibC.Int16)
  => BG.CompatHasField.HasField "unwrap" Sint16 ty
  where
  hasField :: Sint16 -> (ty -> Sint16, ty)
hasField =
    \Sint16
x0 ->
      ( \ty
y1 ->
          Sint16{unwrap :: Int16
unwrap = ty
Int16
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" Sint16
x0
      )

instance
  (ty ~ HsBindgen.Runtime.LibC.Int16)
  => BG.HasField "unwrap" (BG.Ptr Sint16) (BG.Ptr ty)
  where
  getField :: Ptr Sint16 -> Ptr ty
getField = Proxy "unwrap" -> Ptr Sint16 -> Ptr (CFieldType Sint16 "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField Sint16 "unwrap" where
  type
    CFieldType Sint16 "unwrap" =
      HsBindgen.Runtime.LibC.Int16

  offset# :: Proxy# Sint16 -> Proxy# "unwrap" -> Int
offset# = \Proxy# Sint16
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | An unsigned 16-bit integer type.
--
--     @since 3.2.0
--
--     [C declaration]: @Uint16@, defined at @SDL3\/SDL_stdinc.h 464:18@
newtype Uint16 = Uint16
  { Uint16 -> Word16
unwrap :: HsBindgen.Runtime.LibC.Word16
  }
  deriving stock ((forall x. Uint16 -> Rep Uint16 x)
-> (forall x. Rep Uint16 x -> Uint16) -> Generic Uint16
forall x. Rep Uint16 x -> Uint16
forall x. Uint16 -> Rep Uint16 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Uint16 -> Rep Uint16 x
from :: forall x. Uint16 -> Rep Uint16 x
$cto :: forall x. Rep Uint16 x -> Uint16
to :: forall x. Rep Uint16 x -> Uint16
BG.Generic, Uint16 -> Uint16 -> Bool
(Uint16 -> Uint16 -> Bool)
-> (Uint16 -> Uint16 -> Bool) -> Eq Uint16
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Uint16 -> Uint16 -> Bool
== :: Uint16 -> Uint16 -> Bool
$c/= :: Uint16 -> Uint16 -> Bool
/= :: Uint16 -> Uint16 -> Bool
Eq, Eq Uint16
Eq Uint16 =>
(Uint16 -> Uint16 -> Ordering)
-> (Uint16 -> Uint16 -> Bool)
-> (Uint16 -> Uint16 -> Bool)
-> (Uint16 -> Uint16 -> Bool)
-> (Uint16 -> Uint16 -> Bool)
-> (Uint16 -> Uint16 -> Uint16)
-> (Uint16 -> Uint16 -> Uint16)
-> Ord Uint16
Uint16 -> Uint16 -> Bool
Uint16 -> Uint16 -> Ordering
Uint16 -> Uint16 -> Uint16
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
$ccompare :: Uint16 -> Uint16 -> Ordering
compare :: Uint16 -> Uint16 -> Ordering
$c< :: Uint16 -> Uint16 -> Bool
< :: Uint16 -> Uint16 -> Bool
$c<= :: Uint16 -> Uint16 -> Bool
<= :: Uint16 -> Uint16 -> Bool
$c> :: Uint16 -> Uint16 -> Bool
> :: Uint16 -> Uint16 -> Bool
$c>= :: Uint16 -> Uint16 -> Bool
>= :: Uint16 -> Uint16 -> Bool
$cmax :: Uint16 -> Uint16 -> Uint16
max :: Uint16 -> Uint16 -> Uint16
$cmin :: Uint16 -> Uint16 -> Uint16
min :: Uint16 -> Uint16 -> Uint16
Ord, ReadPrec [Uint16]
ReadPrec Uint16
Int -> ReadS Uint16
ReadS [Uint16]
(Int -> ReadS Uint16)
-> ReadS [Uint16]
-> ReadPrec Uint16
-> ReadPrec [Uint16]
-> Read Uint16
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Uint16
readsPrec :: Int -> ReadS Uint16
$creadList :: ReadS [Uint16]
readList :: ReadS [Uint16]
$creadPrec :: ReadPrec Uint16
readPrec :: ReadPrec Uint16
$creadListPrec :: ReadPrec [Uint16]
readListPrec :: ReadPrec [Uint16]
Read, Int -> Uint16 -> ShowS
[Uint16] -> ShowS
Uint16 -> String
(Int -> Uint16 -> ShowS)
-> (Uint16 -> String) -> ([Uint16] -> ShowS) -> Show Uint16
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Uint16 -> ShowS
showsPrec :: Int -> Uint16 -> ShowS
$cshow :: Uint16 -> String
show :: Uint16 -> String
$cshowList :: [Uint16] -> ShowS
showList :: [Uint16] -> ShowS
Show)
  deriving newtype
    ( Word64 -> Int -> Uint16
Uint16 -> Int -> Word64
(Uint16 -> Int -> Word64)
-> (Word64 -> Int -> Uint16) -> Bitfield Uint16
forall a.
(a -> Int -> Word64) -> (Word64 -> Int -> a) -> Bitfield a
$cnarrow :: Uint16 -> Int -> Word64
narrow :: Uint16 -> Int -> Word64
$cextend :: Word64 -> Int -> Uint16
extend :: Word64 -> Int -> Uint16
BG.Bitfield
    , Eq Uint16
Uint16
Eq Uint16 =>
(Uint16 -> Uint16 -> Uint16)
-> (Uint16 -> Uint16 -> Uint16)
-> (Uint16 -> Uint16 -> Uint16)
-> (Uint16 -> Uint16)
-> (Uint16 -> Int -> Uint16)
-> (Uint16 -> Int -> Uint16)
-> Uint16
-> (Int -> Uint16)
-> (Uint16 -> Int -> Uint16)
-> (Uint16 -> Int -> Uint16)
-> (Uint16 -> Int -> Uint16)
-> (Uint16 -> Int -> Bool)
-> (Uint16 -> Maybe Int)
-> (Uint16 -> Int)
-> (Uint16 -> Bool)
-> (Uint16 -> Int -> Uint16)
-> (Uint16 -> Int -> Uint16)
-> (Uint16 -> Int -> Uint16)
-> (Uint16 -> Int -> Uint16)
-> (Uint16 -> Int -> Uint16)
-> (Uint16 -> Int -> Uint16)
-> (Uint16 -> Int)
-> Bits Uint16
Int -> Uint16
Uint16 -> Bool
Uint16 -> Int
Uint16 -> Maybe Int
Uint16 -> Uint16
Uint16 -> Int -> Bool
Uint16 -> Int -> Uint16
Uint16 -> Uint16 -> Uint16
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
$c.&. :: Uint16 -> Uint16 -> Uint16
.&. :: Uint16 -> Uint16 -> Uint16
$c.|. :: Uint16 -> Uint16 -> Uint16
.|. :: Uint16 -> Uint16 -> Uint16
$cxor :: Uint16 -> Uint16 -> Uint16
xor :: Uint16 -> Uint16 -> Uint16
$ccomplement :: Uint16 -> Uint16
complement :: Uint16 -> Uint16
$cshift :: Uint16 -> Int -> Uint16
shift :: Uint16 -> Int -> Uint16
$crotate :: Uint16 -> Int -> Uint16
rotate :: Uint16 -> Int -> Uint16
$czeroBits :: Uint16
zeroBits :: Uint16
$cbit :: Int -> Uint16
bit :: Int -> Uint16
$csetBit :: Uint16 -> Int -> Uint16
setBit :: Uint16 -> Int -> Uint16
$cclearBit :: Uint16 -> Int -> Uint16
clearBit :: Uint16 -> Int -> Uint16
$ccomplementBit :: Uint16 -> Int -> Uint16
complementBit :: Uint16 -> Int -> Uint16
$ctestBit :: Uint16 -> Int -> Bool
testBit :: Uint16 -> Int -> Bool
$cbitSizeMaybe :: Uint16 -> Maybe Int
bitSizeMaybe :: Uint16 -> Maybe Int
$cbitSize :: Uint16 -> Int
bitSize :: Uint16 -> Int
$cisSigned :: Uint16 -> Bool
isSigned :: Uint16 -> Bool
$cshiftL :: Uint16 -> Int -> Uint16
shiftL :: Uint16 -> Int -> Uint16
$cunsafeShiftL :: Uint16 -> Int -> Uint16
unsafeShiftL :: Uint16 -> Int -> Uint16
$cshiftR :: Uint16 -> Int -> Uint16
shiftR :: Uint16 -> Int -> Uint16
$cunsafeShiftR :: Uint16 -> Int -> Uint16
unsafeShiftR :: Uint16 -> Int -> Uint16
$crotateL :: Uint16 -> Int -> Uint16
rotateL :: Uint16 -> Int -> Uint16
$crotateR :: Uint16 -> Int -> Uint16
rotateR :: Uint16 -> Int -> Uint16
$cpopCount :: Uint16 -> Int
popCount :: Uint16 -> Int
BG.Bits
    , Bits Uint16
Bits Uint16 =>
(Uint16 -> Int)
-> (Uint16 -> Int) -> (Uint16 -> Int) -> FiniteBits Uint16
Uint16 -> Int
forall b.
Bits b =>
(b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
$cfiniteBitSize :: Uint16 -> Int
finiteBitSize :: Uint16 -> Int
$ccountLeadingZeros :: Uint16 -> Int
countLeadingZeros :: Uint16 -> Int
$ccountTrailingZeros :: Uint16 -> Int
countTrailingZeros :: Uint16 -> Int
BG.FiniteBits
    , FFIType Uint16 -> Uint16
Uint16 -> FFIType Uint16
(Uint16 -> FFIType Uint16)
-> (FFIType Uint16 -> Uint16) -> HasFFIType Uint16
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: Uint16 -> FFIType Uint16
toFFIType :: Uint16 -> FFIType Uint16
$cfromFFIType :: FFIType Uint16 -> Uint16
fromFFIType :: FFIType Uint16 -> Uint16
BG.HasFFIType
    , Ord Uint16
Ord Uint16 =>
((Uint16, Uint16) -> [Uint16])
-> ((Uint16, Uint16) -> Uint16 -> Int)
-> ((Uint16, Uint16) -> Uint16 -> Int)
-> ((Uint16, Uint16) -> Uint16 -> Bool)
-> ((Uint16, Uint16) -> Int)
-> ((Uint16, Uint16) -> Int)
-> Ix Uint16
(Uint16, Uint16) -> Int
(Uint16, Uint16) -> [Uint16]
(Uint16, Uint16) -> Uint16 -> Bool
(Uint16, Uint16) -> Uint16 -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
$crange :: (Uint16, Uint16) -> [Uint16]
range :: (Uint16, Uint16) -> [Uint16]
$cindex :: (Uint16, Uint16) -> Uint16 -> Int
index :: (Uint16, Uint16) -> Uint16 -> Int
$cunsafeIndex :: (Uint16, Uint16) -> Uint16 -> Int
unsafeIndex :: (Uint16, Uint16) -> Uint16 -> Int
$cinRange :: (Uint16, Uint16) -> Uint16 -> Bool
inRange :: (Uint16, Uint16) -> Uint16 -> Bool
$crangeSize :: (Uint16, Uint16) -> Int
rangeSize :: (Uint16, Uint16) -> Int
$cunsafeRangeSize :: (Uint16, Uint16) -> Int
unsafeRangeSize :: (Uint16, Uint16) -> Int
BG.Ix
    , Addr# -> Int# -> Uint16
ByteArray# -> Int# -> Uint16
Proxy Uint16 -> Int#
Uint16 -> Int#
(Proxy Uint16 -> Int#)
-> (Uint16 -> Int#)
-> (Proxy Uint16 -> Int#)
-> (Uint16 -> Int#)
-> (ByteArray# -> Int# -> Uint16)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint16 #))
-> (forall s.
    MutableByteArray# s -> Int# -> Uint16 -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s
    -> Int# -> Int# -> Uint16 -> State# s -> State# s)
-> (Addr# -> Int# -> Uint16)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, Uint16 #))
-> (forall s. Addr# -> Int# -> Uint16 -> State# s -> State# s)
-> (forall s.
    Addr# -> Int# -> Int# -> Uint16 -> State# s -> State# s)
-> Prim Uint16
forall s. Addr# -> Int# -> Int# -> Uint16 -> State# s -> State# s
forall s. Addr# -> Int# -> State# s -> (# State# s, Uint16 #)
forall s. Addr# -> Int# -> Uint16 -> State# s -> State# s
forall s.
MutableByteArray# s
-> Int# -> Int# -> Uint16 -> State# s -> State# s
forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint16 #)
forall s.
MutableByteArray# s -> Int# -> Uint16 -> State# s -> State# s
forall a.
(Proxy a -> Int#)
-> (a -> Int#)
-> (Proxy a -> Int#)
-> (a -> Int#)
-> (ByteArray# -> Int# -> a)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, a #))
-> (forall s.
    MutableByteArray# s -> Int# -> a -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s)
-> (Addr# -> Int# -> a)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, a #))
-> (forall s. Addr# -> Int# -> a -> State# s -> State# s)
-> (forall s. Addr# -> Int# -> Int# -> a -> State# s -> State# s)
-> Prim a
$csizeOfType# :: Proxy Uint16 -> Int#
sizeOfType# :: Proxy Uint16 -> Int#
$csizeOf# :: Uint16 -> Int#
sizeOf# :: Uint16 -> Int#
$calignmentOfType# :: Proxy Uint16 -> Int#
alignmentOfType# :: Proxy Uint16 -> Int#
$calignment# :: Uint16 -> Int#
alignment# :: Uint16 -> Int#
$cindexByteArray# :: ByteArray# -> Int# -> Uint16
indexByteArray# :: ByteArray# -> Int# -> Uint16
$creadByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint16 #)
readByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint16 #)
$cwriteByteArray# :: forall s.
MutableByteArray# s -> Int# -> Uint16 -> State# s -> State# s
writeByteArray# :: forall s.
MutableByteArray# s -> Int# -> Uint16 -> State# s -> State# s
$csetByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Uint16 -> State# s -> State# s
setByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Uint16 -> State# s -> State# s
$cindexOffAddr# :: Addr# -> Int# -> Uint16
indexOffAddr# :: Addr# -> Int# -> Uint16
$creadOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Uint16 #)
readOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Uint16 #)
$cwriteOffAddr# :: forall s. Addr# -> Int# -> Uint16 -> State# s -> State# s
writeOffAddr# :: forall s. Addr# -> Int# -> Uint16 -> State# s -> State# s
$csetOffAddr# :: forall s. Addr# -> Int# -> Int# -> Uint16 -> State# s -> State# s
setOffAddr# :: forall s. Addr# -> Int# -> Int# -> Uint16 -> State# s -> State# s
BG.Prim
    , Ptr Uint16 -> IO Uint16
Ptr Uint16 -> Int -> IO Uint16
Ptr Uint16 -> Int -> Uint16 -> IO ()
Ptr Uint16 -> Uint16 -> IO ()
Uint16 -> Int
(Uint16 -> Int)
-> (Uint16 -> Int)
-> (Ptr Uint16 -> Int -> IO Uint16)
-> (Ptr Uint16 -> Int -> Uint16 -> IO ())
-> (forall b. Ptr b -> Int -> IO Uint16)
-> (forall b. Ptr b -> Int -> Uint16 -> IO ())
-> (Ptr Uint16 -> IO Uint16)
-> (Ptr Uint16 -> Uint16 -> IO ())
-> Storable Uint16
forall b. Ptr b -> Int -> IO Uint16
forall b. Ptr b -> Int -> Uint16 -> 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
$csizeOf :: Uint16 -> Int
sizeOf :: Uint16 -> Int
$calignment :: Uint16 -> Int
alignment :: Uint16 -> Int
$cpeekElemOff :: Ptr Uint16 -> Int -> IO Uint16
peekElemOff :: Ptr Uint16 -> Int -> IO Uint16
$cpokeElemOff :: Ptr Uint16 -> Int -> Uint16 -> IO ()
pokeElemOff :: Ptr Uint16 -> Int -> Uint16 -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Uint16
peekByteOff :: forall b. Ptr b -> Int -> IO Uint16
$cpokeByteOff :: forall b. Ptr b -> Int -> Uint16 -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> Uint16 -> IO ()
$cpeek :: Ptr Uint16 -> IO Uint16
peek :: Ptr Uint16 -> IO Uint16
$cpoke :: Ptr Uint16 -> Uint16 -> IO ()
poke :: Ptr Uint16 -> Uint16 -> IO ()
BG.Storable
    , Uint16
Uint16 -> Uint16 -> Bounded Uint16
forall a. a -> a -> Bounded a
$cminBound :: Uint16
minBound :: Uint16
$cmaxBound :: Uint16
maxBound :: Uint16
Bounded
    , Int -> Uint16
Uint16 -> Int
Uint16 -> [Uint16]
Uint16 -> Uint16
Uint16 -> Uint16 -> [Uint16]
Uint16 -> Uint16 -> Uint16 -> [Uint16]
(Uint16 -> Uint16)
-> (Uint16 -> Uint16)
-> (Int -> Uint16)
-> (Uint16 -> Int)
-> (Uint16 -> [Uint16])
-> (Uint16 -> Uint16 -> [Uint16])
-> (Uint16 -> Uint16 -> [Uint16])
-> (Uint16 -> Uint16 -> Uint16 -> [Uint16])
-> Enum Uint16
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Uint16 -> Uint16
succ :: Uint16 -> Uint16
$cpred :: Uint16 -> Uint16
pred :: Uint16 -> Uint16
$ctoEnum :: Int -> Uint16
toEnum :: Int -> Uint16
$cfromEnum :: Uint16 -> Int
fromEnum :: Uint16 -> Int
$cenumFrom :: Uint16 -> [Uint16]
enumFrom :: Uint16 -> [Uint16]
$cenumFromThen :: Uint16 -> Uint16 -> [Uint16]
enumFromThen :: Uint16 -> Uint16 -> [Uint16]
$cenumFromTo :: Uint16 -> Uint16 -> [Uint16]
enumFromTo :: Uint16 -> Uint16 -> [Uint16]
$cenumFromThenTo :: Uint16 -> Uint16 -> Uint16 -> [Uint16]
enumFromThenTo :: Uint16 -> Uint16 -> Uint16 -> [Uint16]
Enum
    , Enum Uint16
Real Uint16
(Real Uint16, Enum Uint16) =>
(Uint16 -> Uint16 -> Uint16)
-> (Uint16 -> Uint16 -> Uint16)
-> (Uint16 -> Uint16 -> Uint16)
-> (Uint16 -> Uint16 -> Uint16)
-> (Uint16 -> Uint16 -> (Uint16, Uint16))
-> (Uint16 -> Uint16 -> (Uint16, Uint16))
-> (Uint16 -> Integer)
-> Integral Uint16
Uint16 -> Integer
Uint16 -> Uint16 -> (Uint16, Uint16)
Uint16 -> Uint16 -> Uint16
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
$cquot :: Uint16 -> Uint16 -> Uint16
quot :: Uint16 -> Uint16 -> Uint16
$crem :: Uint16 -> Uint16 -> Uint16
rem :: Uint16 -> Uint16 -> Uint16
$cdiv :: Uint16 -> Uint16 -> Uint16
div :: Uint16 -> Uint16 -> Uint16
$cmod :: Uint16 -> Uint16 -> Uint16
mod :: Uint16 -> Uint16 -> Uint16
$cquotRem :: Uint16 -> Uint16 -> (Uint16, Uint16)
quotRem :: Uint16 -> Uint16 -> (Uint16, Uint16)
$cdivMod :: Uint16 -> Uint16 -> (Uint16, Uint16)
divMod :: Uint16 -> Uint16 -> (Uint16, Uint16)
$ctoInteger :: Uint16 -> Integer
toInteger :: Uint16 -> Integer
Integral
    , Ptr Uint16 -> IO Uint16
(Ptr Uint16 -> IO Uint16) -> ReadRaw Uint16
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr Uint16 -> IO Uint16
readRaw :: Ptr Uint16 -> IO Uint16
Marshal.ReadRaw
    , Proxy Uint16 -> Int
(Proxy Uint16 -> Int) -> (Proxy Uint16 -> Int) -> StaticSize Uint16
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy Uint16 -> Int
staticSizeOf :: Proxy Uint16 -> Int
$cstaticAlignment :: Proxy Uint16 -> Int
staticAlignment :: Proxy Uint16 -> Int
Marshal.StaticSize
    , Ptr Uint16 -> Uint16 -> IO ()
(Ptr Uint16 -> Uint16 -> IO ()) -> WriteRaw Uint16
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr Uint16 -> Uint16 -> IO ()
writeRaw :: Ptr Uint16 -> Uint16 -> IO ()
Marshal.WriteRaw
    , Integer -> Uint16
Uint16 -> Uint16
Uint16 -> Uint16 -> Uint16
(Uint16 -> Uint16 -> Uint16)
-> (Uint16 -> Uint16 -> Uint16)
-> (Uint16 -> Uint16 -> Uint16)
-> (Uint16 -> Uint16)
-> (Uint16 -> Uint16)
-> (Uint16 -> Uint16)
-> (Integer -> Uint16)
-> Num Uint16
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Uint16 -> Uint16 -> Uint16
+ :: Uint16 -> Uint16 -> Uint16
$c- :: Uint16 -> Uint16 -> Uint16
- :: Uint16 -> Uint16 -> Uint16
$c* :: Uint16 -> Uint16 -> Uint16
* :: Uint16 -> Uint16 -> Uint16
$cnegate :: Uint16 -> Uint16
negate :: Uint16 -> Uint16
$cabs :: Uint16 -> Uint16
abs :: Uint16 -> Uint16
$csignum :: Uint16 -> Uint16
signum :: Uint16 -> Uint16
$cfromInteger :: Integer -> Uint16
fromInteger :: Integer -> Uint16
Num
    , Num Uint16
Ord Uint16
(Num Uint16, Ord Uint16) => (Uint16 -> Rational) -> Real Uint16
Uint16 -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Uint16 -> Rational
toRational :: Uint16 -> Rational
Real
    )

instance
  (ty ~ HsBindgen.Runtime.LibC.Word16)
  => BG.CompatHasField.HasField "unwrap" Uint16 ty
  where
  hasField :: Uint16 -> (ty -> Uint16, ty)
hasField =
    \Uint16
x0 ->
      ( \ty
y1 ->
          Uint16{unwrap :: Word16
unwrap = ty
Word16
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" Uint16
x0
      )

instance
  (ty ~ HsBindgen.Runtime.LibC.Word16)
  => BG.HasField "unwrap" (BG.Ptr Uint16) (BG.Ptr ty)
  where
  getField :: Ptr Uint16 -> Ptr ty
getField = Proxy "unwrap" -> Ptr Uint16 -> Ptr (CFieldType Uint16 "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField Uint16 "unwrap" where
  type
    CFieldType Uint16 "unwrap" =
      HsBindgen.Runtime.LibC.Word16

  offset# :: Proxy# Uint16 -> Proxy# "unwrap" -> Int
offset# = \Proxy# Uint16
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | A signed 32-bit integer type.
--
--     @since 3.2.0
--
--     [C declaration]: @Sint32@, defined at @SDL3\/SDL_stdinc.h 473:17@
newtype Sint32 = Sint32
  { Sint32 -> Int32
unwrap :: HsBindgen.Runtime.LibC.Int32
  }
  deriving stock ((forall x. Sint32 -> Rep Sint32 x)
-> (forall x. Rep Sint32 x -> Sint32) -> Generic Sint32
forall x. Rep Sint32 x -> Sint32
forall x. Sint32 -> Rep Sint32 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Sint32 -> Rep Sint32 x
from :: forall x. Sint32 -> Rep Sint32 x
$cto :: forall x. Rep Sint32 x -> Sint32
to :: forall x. Rep Sint32 x -> Sint32
BG.Generic, Sint32 -> Sint32 -> Bool
(Sint32 -> Sint32 -> Bool)
-> (Sint32 -> Sint32 -> Bool) -> Eq Sint32
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Sint32 -> Sint32 -> Bool
== :: Sint32 -> Sint32 -> Bool
$c/= :: Sint32 -> Sint32 -> Bool
/= :: Sint32 -> Sint32 -> Bool
Eq, Eq Sint32
Eq Sint32 =>
(Sint32 -> Sint32 -> Ordering)
-> (Sint32 -> Sint32 -> Bool)
-> (Sint32 -> Sint32 -> Bool)
-> (Sint32 -> Sint32 -> Bool)
-> (Sint32 -> Sint32 -> Bool)
-> (Sint32 -> Sint32 -> Sint32)
-> (Sint32 -> Sint32 -> Sint32)
-> Ord Sint32
Sint32 -> Sint32 -> Bool
Sint32 -> Sint32 -> Ordering
Sint32 -> Sint32 -> Sint32
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
$ccompare :: Sint32 -> Sint32 -> Ordering
compare :: Sint32 -> Sint32 -> Ordering
$c< :: Sint32 -> Sint32 -> Bool
< :: Sint32 -> Sint32 -> Bool
$c<= :: Sint32 -> Sint32 -> Bool
<= :: Sint32 -> Sint32 -> Bool
$c> :: Sint32 -> Sint32 -> Bool
> :: Sint32 -> Sint32 -> Bool
$c>= :: Sint32 -> Sint32 -> Bool
>= :: Sint32 -> Sint32 -> Bool
$cmax :: Sint32 -> Sint32 -> Sint32
max :: Sint32 -> Sint32 -> Sint32
$cmin :: Sint32 -> Sint32 -> Sint32
min :: Sint32 -> Sint32 -> Sint32
Ord, ReadPrec [Sint32]
ReadPrec Sint32
Int -> ReadS Sint32
ReadS [Sint32]
(Int -> ReadS Sint32)
-> ReadS [Sint32]
-> ReadPrec Sint32
-> ReadPrec [Sint32]
-> Read Sint32
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Sint32
readsPrec :: Int -> ReadS Sint32
$creadList :: ReadS [Sint32]
readList :: ReadS [Sint32]
$creadPrec :: ReadPrec Sint32
readPrec :: ReadPrec Sint32
$creadListPrec :: ReadPrec [Sint32]
readListPrec :: ReadPrec [Sint32]
Read, Int -> Sint32 -> ShowS
[Sint32] -> ShowS
Sint32 -> String
(Int -> Sint32 -> ShowS)
-> (Sint32 -> String) -> ([Sint32] -> ShowS) -> Show Sint32
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Sint32 -> ShowS
showsPrec :: Int -> Sint32 -> ShowS
$cshow :: Sint32 -> String
show :: Sint32 -> String
$cshowList :: [Sint32] -> ShowS
showList :: [Sint32] -> ShowS
Show)
  deriving newtype
    ( Word64 -> Int -> Sint32
Sint32 -> Int -> Word64
(Sint32 -> Int -> Word64)
-> (Word64 -> Int -> Sint32) -> Bitfield Sint32
forall a.
(a -> Int -> Word64) -> (Word64 -> Int -> a) -> Bitfield a
$cnarrow :: Sint32 -> Int -> Word64
narrow :: Sint32 -> Int -> Word64
$cextend :: Word64 -> Int -> Sint32
extend :: Word64 -> Int -> Sint32
BG.Bitfield
    , Eq Sint32
Sint32
Eq Sint32 =>
(Sint32 -> Sint32 -> Sint32)
-> (Sint32 -> Sint32 -> Sint32)
-> (Sint32 -> Sint32 -> Sint32)
-> (Sint32 -> Sint32)
-> (Sint32 -> Int -> Sint32)
-> (Sint32 -> Int -> Sint32)
-> Sint32
-> (Int -> Sint32)
-> (Sint32 -> Int -> Sint32)
-> (Sint32 -> Int -> Sint32)
-> (Sint32 -> Int -> Sint32)
-> (Sint32 -> Int -> Bool)
-> (Sint32 -> Maybe Int)
-> (Sint32 -> Int)
-> (Sint32 -> Bool)
-> (Sint32 -> Int -> Sint32)
-> (Sint32 -> Int -> Sint32)
-> (Sint32 -> Int -> Sint32)
-> (Sint32 -> Int -> Sint32)
-> (Sint32 -> Int -> Sint32)
-> (Sint32 -> Int -> Sint32)
-> (Sint32 -> Int)
-> Bits Sint32
Int -> Sint32
Sint32 -> Bool
Sint32 -> Int
Sint32 -> Maybe Int
Sint32 -> Sint32
Sint32 -> Int -> Bool
Sint32 -> Int -> Sint32
Sint32 -> Sint32 -> Sint32
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
$c.&. :: Sint32 -> Sint32 -> Sint32
.&. :: Sint32 -> Sint32 -> Sint32
$c.|. :: Sint32 -> Sint32 -> Sint32
.|. :: Sint32 -> Sint32 -> Sint32
$cxor :: Sint32 -> Sint32 -> Sint32
xor :: Sint32 -> Sint32 -> Sint32
$ccomplement :: Sint32 -> Sint32
complement :: Sint32 -> Sint32
$cshift :: Sint32 -> Int -> Sint32
shift :: Sint32 -> Int -> Sint32
$crotate :: Sint32 -> Int -> Sint32
rotate :: Sint32 -> Int -> Sint32
$czeroBits :: Sint32
zeroBits :: Sint32
$cbit :: Int -> Sint32
bit :: Int -> Sint32
$csetBit :: Sint32 -> Int -> Sint32
setBit :: Sint32 -> Int -> Sint32
$cclearBit :: Sint32 -> Int -> Sint32
clearBit :: Sint32 -> Int -> Sint32
$ccomplementBit :: Sint32 -> Int -> Sint32
complementBit :: Sint32 -> Int -> Sint32
$ctestBit :: Sint32 -> Int -> Bool
testBit :: Sint32 -> Int -> Bool
$cbitSizeMaybe :: Sint32 -> Maybe Int
bitSizeMaybe :: Sint32 -> Maybe Int
$cbitSize :: Sint32 -> Int
bitSize :: Sint32 -> Int
$cisSigned :: Sint32 -> Bool
isSigned :: Sint32 -> Bool
$cshiftL :: Sint32 -> Int -> Sint32
shiftL :: Sint32 -> Int -> Sint32
$cunsafeShiftL :: Sint32 -> Int -> Sint32
unsafeShiftL :: Sint32 -> Int -> Sint32
$cshiftR :: Sint32 -> Int -> Sint32
shiftR :: Sint32 -> Int -> Sint32
$cunsafeShiftR :: Sint32 -> Int -> Sint32
unsafeShiftR :: Sint32 -> Int -> Sint32
$crotateL :: Sint32 -> Int -> Sint32
rotateL :: Sint32 -> Int -> Sint32
$crotateR :: Sint32 -> Int -> Sint32
rotateR :: Sint32 -> Int -> Sint32
$cpopCount :: Sint32 -> Int
popCount :: Sint32 -> Int
BG.Bits
    , Bits Sint32
Bits Sint32 =>
(Sint32 -> Int)
-> (Sint32 -> Int) -> (Sint32 -> Int) -> FiniteBits Sint32
Sint32 -> Int
forall b.
Bits b =>
(b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
$cfiniteBitSize :: Sint32 -> Int
finiteBitSize :: Sint32 -> Int
$ccountLeadingZeros :: Sint32 -> Int
countLeadingZeros :: Sint32 -> Int
$ccountTrailingZeros :: Sint32 -> Int
countTrailingZeros :: Sint32 -> Int
BG.FiniteBits
    , FFIType Sint32 -> Sint32
Sint32 -> FFIType Sint32
(Sint32 -> FFIType Sint32)
-> (FFIType Sint32 -> Sint32) -> HasFFIType Sint32
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: Sint32 -> FFIType Sint32
toFFIType :: Sint32 -> FFIType Sint32
$cfromFFIType :: FFIType Sint32 -> Sint32
fromFFIType :: FFIType Sint32 -> Sint32
BG.HasFFIType
    , Ord Sint32
Ord Sint32 =>
((Sint32, Sint32) -> [Sint32])
-> ((Sint32, Sint32) -> Sint32 -> Int)
-> ((Sint32, Sint32) -> Sint32 -> Int)
-> ((Sint32, Sint32) -> Sint32 -> Bool)
-> ((Sint32, Sint32) -> Int)
-> ((Sint32, Sint32) -> Int)
-> Ix Sint32
(Sint32, Sint32) -> Int
(Sint32, Sint32) -> [Sint32]
(Sint32, Sint32) -> Sint32 -> Bool
(Sint32, Sint32) -> Sint32 -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
$crange :: (Sint32, Sint32) -> [Sint32]
range :: (Sint32, Sint32) -> [Sint32]
$cindex :: (Sint32, Sint32) -> Sint32 -> Int
index :: (Sint32, Sint32) -> Sint32 -> Int
$cunsafeIndex :: (Sint32, Sint32) -> Sint32 -> Int
unsafeIndex :: (Sint32, Sint32) -> Sint32 -> Int
$cinRange :: (Sint32, Sint32) -> Sint32 -> Bool
inRange :: (Sint32, Sint32) -> Sint32 -> Bool
$crangeSize :: (Sint32, Sint32) -> Int
rangeSize :: (Sint32, Sint32) -> Int
$cunsafeRangeSize :: (Sint32, Sint32) -> Int
unsafeRangeSize :: (Sint32, Sint32) -> Int
BG.Ix
    , Addr# -> Int# -> Sint32
ByteArray# -> Int# -> Sint32
Proxy Sint32 -> Int#
Sint32 -> Int#
(Proxy Sint32 -> Int#)
-> (Sint32 -> Int#)
-> (Proxy Sint32 -> Int#)
-> (Sint32 -> Int#)
-> (ByteArray# -> Int# -> Sint32)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint32 #))
-> (forall s.
    MutableByteArray# s -> Int# -> Sint32 -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s
    -> Int# -> Int# -> Sint32 -> State# s -> State# s)
-> (Addr# -> Int# -> Sint32)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, Sint32 #))
-> (forall s. Addr# -> Int# -> Sint32 -> State# s -> State# s)
-> (forall s.
    Addr# -> Int# -> Int# -> Sint32 -> State# s -> State# s)
-> Prim Sint32
forall s. Addr# -> Int# -> Int# -> Sint32 -> State# s -> State# s
forall s. Addr# -> Int# -> State# s -> (# State# s, Sint32 #)
forall s. Addr# -> Int# -> Sint32 -> State# s -> State# s
forall s.
MutableByteArray# s
-> Int# -> Int# -> Sint32 -> State# s -> State# s
forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint32 #)
forall s.
MutableByteArray# s -> Int# -> Sint32 -> State# s -> State# s
forall a.
(Proxy a -> Int#)
-> (a -> Int#)
-> (Proxy a -> Int#)
-> (a -> Int#)
-> (ByteArray# -> Int# -> a)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, a #))
-> (forall s.
    MutableByteArray# s -> Int# -> a -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s)
-> (Addr# -> Int# -> a)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, a #))
-> (forall s. Addr# -> Int# -> a -> State# s -> State# s)
-> (forall s. Addr# -> Int# -> Int# -> a -> State# s -> State# s)
-> Prim a
$csizeOfType# :: Proxy Sint32 -> Int#
sizeOfType# :: Proxy Sint32 -> Int#
$csizeOf# :: Sint32 -> Int#
sizeOf# :: Sint32 -> Int#
$calignmentOfType# :: Proxy Sint32 -> Int#
alignmentOfType# :: Proxy Sint32 -> Int#
$calignment# :: Sint32 -> Int#
alignment# :: Sint32 -> Int#
$cindexByteArray# :: ByteArray# -> Int# -> Sint32
indexByteArray# :: ByteArray# -> Int# -> Sint32
$creadByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint32 #)
readByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint32 #)
$cwriteByteArray# :: forall s.
MutableByteArray# s -> Int# -> Sint32 -> State# s -> State# s
writeByteArray# :: forall s.
MutableByteArray# s -> Int# -> Sint32 -> State# s -> State# s
$csetByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Sint32 -> State# s -> State# s
setByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Sint32 -> State# s -> State# s
$cindexOffAddr# :: Addr# -> Int# -> Sint32
indexOffAddr# :: Addr# -> Int# -> Sint32
$creadOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Sint32 #)
readOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Sint32 #)
$cwriteOffAddr# :: forall s. Addr# -> Int# -> Sint32 -> State# s -> State# s
writeOffAddr# :: forall s. Addr# -> Int# -> Sint32 -> State# s -> State# s
$csetOffAddr# :: forall s. Addr# -> Int# -> Int# -> Sint32 -> State# s -> State# s
setOffAddr# :: forall s. Addr# -> Int# -> Int# -> Sint32 -> State# s -> State# s
BG.Prim
    , Ptr Sint32 -> IO Sint32
Ptr Sint32 -> Int -> IO Sint32
Ptr Sint32 -> Int -> Sint32 -> IO ()
Ptr Sint32 -> Sint32 -> IO ()
Sint32 -> Int
(Sint32 -> Int)
-> (Sint32 -> Int)
-> (Ptr Sint32 -> Int -> IO Sint32)
-> (Ptr Sint32 -> Int -> Sint32 -> IO ())
-> (forall b. Ptr b -> Int -> IO Sint32)
-> (forall b. Ptr b -> Int -> Sint32 -> IO ())
-> (Ptr Sint32 -> IO Sint32)
-> (Ptr Sint32 -> Sint32 -> IO ())
-> Storable Sint32
forall b. Ptr b -> Int -> IO Sint32
forall b. Ptr b -> Int -> Sint32 -> 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
$csizeOf :: Sint32 -> Int
sizeOf :: Sint32 -> Int
$calignment :: Sint32 -> Int
alignment :: Sint32 -> Int
$cpeekElemOff :: Ptr Sint32 -> Int -> IO Sint32
peekElemOff :: Ptr Sint32 -> Int -> IO Sint32
$cpokeElemOff :: Ptr Sint32 -> Int -> Sint32 -> IO ()
pokeElemOff :: Ptr Sint32 -> Int -> Sint32 -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Sint32
peekByteOff :: forall b. Ptr b -> Int -> IO Sint32
$cpokeByteOff :: forall b. Ptr b -> Int -> Sint32 -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> Sint32 -> IO ()
$cpeek :: Ptr Sint32 -> IO Sint32
peek :: Ptr Sint32 -> IO Sint32
$cpoke :: Ptr Sint32 -> Sint32 -> IO ()
poke :: Ptr Sint32 -> Sint32 -> IO ()
BG.Storable
    , Sint32
Sint32 -> Sint32 -> Bounded Sint32
forall a. a -> a -> Bounded a
$cminBound :: Sint32
minBound :: Sint32
$cmaxBound :: Sint32
maxBound :: Sint32
Bounded
    , Int -> Sint32
Sint32 -> Int
Sint32 -> [Sint32]
Sint32 -> Sint32
Sint32 -> Sint32 -> [Sint32]
Sint32 -> Sint32 -> Sint32 -> [Sint32]
(Sint32 -> Sint32)
-> (Sint32 -> Sint32)
-> (Int -> Sint32)
-> (Sint32 -> Int)
-> (Sint32 -> [Sint32])
-> (Sint32 -> Sint32 -> [Sint32])
-> (Sint32 -> Sint32 -> [Sint32])
-> (Sint32 -> Sint32 -> Sint32 -> [Sint32])
-> Enum Sint32
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Sint32 -> Sint32
succ :: Sint32 -> Sint32
$cpred :: Sint32 -> Sint32
pred :: Sint32 -> Sint32
$ctoEnum :: Int -> Sint32
toEnum :: Int -> Sint32
$cfromEnum :: Sint32 -> Int
fromEnum :: Sint32 -> Int
$cenumFrom :: Sint32 -> [Sint32]
enumFrom :: Sint32 -> [Sint32]
$cenumFromThen :: Sint32 -> Sint32 -> [Sint32]
enumFromThen :: Sint32 -> Sint32 -> [Sint32]
$cenumFromTo :: Sint32 -> Sint32 -> [Sint32]
enumFromTo :: Sint32 -> Sint32 -> [Sint32]
$cenumFromThenTo :: Sint32 -> Sint32 -> Sint32 -> [Sint32]
enumFromThenTo :: Sint32 -> Sint32 -> Sint32 -> [Sint32]
Enum
    , Enum Sint32
Real Sint32
(Real Sint32, Enum Sint32) =>
(Sint32 -> Sint32 -> Sint32)
-> (Sint32 -> Sint32 -> Sint32)
-> (Sint32 -> Sint32 -> Sint32)
-> (Sint32 -> Sint32 -> Sint32)
-> (Sint32 -> Sint32 -> (Sint32, Sint32))
-> (Sint32 -> Sint32 -> (Sint32, Sint32))
-> (Sint32 -> Integer)
-> Integral Sint32
Sint32 -> Integer
Sint32 -> Sint32 -> (Sint32, Sint32)
Sint32 -> Sint32 -> Sint32
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
$cquot :: Sint32 -> Sint32 -> Sint32
quot :: Sint32 -> Sint32 -> Sint32
$crem :: Sint32 -> Sint32 -> Sint32
rem :: Sint32 -> Sint32 -> Sint32
$cdiv :: Sint32 -> Sint32 -> Sint32
div :: Sint32 -> Sint32 -> Sint32
$cmod :: Sint32 -> Sint32 -> Sint32
mod :: Sint32 -> Sint32 -> Sint32
$cquotRem :: Sint32 -> Sint32 -> (Sint32, Sint32)
quotRem :: Sint32 -> Sint32 -> (Sint32, Sint32)
$cdivMod :: Sint32 -> Sint32 -> (Sint32, Sint32)
divMod :: Sint32 -> Sint32 -> (Sint32, Sint32)
$ctoInteger :: Sint32 -> Integer
toInteger :: Sint32 -> Integer
Integral
    , Ptr Sint32 -> IO Sint32
(Ptr Sint32 -> IO Sint32) -> ReadRaw Sint32
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr Sint32 -> IO Sint32
readRaw :: Ptr Sint32 -> IO Sint32
Marshal.ReadRaw
    , Proxy Sint32 -> Int
(Proxy Sint32 -> Int) -> (Proxy Sint32 -> Int) -> StaticSize Sint32
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy Sint32 -> Int
staticSizeOf :: Proxy Sint32 -> Int
$cstaticAlignment :: Proxy Sint32 -> Int
staticAlignment :: Proxy Sint32 -> Int
Marshal.StaticSize
    , Ptr Sint32 -> Sint32 -> IO ()
(Ptr Sint32 -> Sint32 -> IO ()) -> WriteRaw Sint32
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr Sint32 -> Sint32 -> IO ()
writeRaw :: Ptr Sint32 -> Sint32 -> IO ()
Marshal.WriteRaw
    , Integer -> Sint32
Sint32 -> Sint32
Sint32 -> Sint32 -> Sint32
(Sint32 -> Sint32 -> Sint32)
-> (Sint32 -> Sint32 -> Sint32)
-> (Sint32 -> Sint32 -> Sint32)
-> (Sint32 -> Sint32)
-> (Sint32 -> Sint32)
-> (Sint32 -> Sint32)
-> (Integer -> Sint32)
-> Num Sint32
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Sint32 -> Sint32 -> Sint32
+ :: Sint32 -> Sint32 -> Sint32
$c- :: Sint32 -> Sint32 -> Sint32
- :: Sint32 -> Sint32 -> Sint32
$c* :: Sint32 -> Sint32 -> Sint32
* :: Sint32 -> Sint32 -> Sint32
$cnegate :: Sint32 -> Sint32
negate :: Sint32 -> Sint32
$cabs :: Sint32 -> Sint32
abs :: Sint32 -> Sint32
$csignum :: Sint32 -> Sint32
signum :: Sint32 -> Sint32
$cfromInteger :: Integer -> Sint32
fromInteger :: Integer -> Sint32
Num
    , Num Sint32
Ord Sint32
(Num Sint32, Ord Sint32) => (Sint32 -> Rational) -> Real Sint32
Sint32 -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Sint32 -> Rational
toRational :: Sint32 -> Rational
Real
    )

instance
  (ty ~ HsBindgen.Runtime.LibC.Int32)
  => BG.CompatHasField.HasField "unwrap" Sint32 ty
  where
  hasField :: Sint32 -> (ty -> Sint32, ty)
hasField =
    \Sint32
x0 ->
      ( \ty
y1 ->
          Sint32{unwrap :: Int32
unwrap = ty
Int32
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" Sint32
x0
      )

instance
  (ty ~ HsBindgen.Runtime.LibC.Int32)
  => BG.HasField "unwrap" (BG.Ptr Sint32) (BG.Ptr ty)
  where
  getField :: Ptr Sint32 -> Ptr ty
getField = Proxy "unwrap" -> Ptr Sint32 -> Ptr (CFieldType Sint32 "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField Sint32 "unwrap" where
  type
    CFieldType Sint32 "unwrap" =
      HsBindgen.Runtime.LibC.Int32

  offset# :: Proxy# Sint32 -> Proxy# "unwrap" -> Int
offset# = \Proxy# Sint32
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | An unsigned 32-bit integer type.
--
--     @since 3.2.0
--
--     [C declaration]: @Uint32@, defined at @SDL3\/SDL_stdinc.h 482:18@
newtype Uint32 = Uint32
  { Uint32 -> Word32
unwrap :: HsBindgen.Runtime.LibC.Word32
  }
  deriving stock ((forall x. Uint32 -> Rep Uint32 x)
-> (forall x. Rep Uint32 x -> Uint32) -> Generic Uint32
forall x. Rep Uint32 x -> Uint32
forall x. Uint32 -> Rep Uint32 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Uint32 -> Rep Uint32 x
from :: forall x. Uint32 -> Rep Uint32 x
$cto :: forall x. Rep Uint32 x -> Uint32
to :: forall x. Rep Uint32 x -> Uint32
BG.Generic, Uint32 -> Uint32 -> Bool
(Uint32 -> Uint32 -> Bool)
-> (Uint32 -> Uint32 -> Bool) -> Eq Uint32
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Uint32 -> Uint32 -> Bool
== :: Uint32 -> Uint32 -> Bool
$c/= :: Uint32 -> Uint32 -> Bool
/= :: Uint32 -> Uint32 -> Bool
Eq, Eq Uint32
Eq Uint32 =>
(Uint32 -> Uint32 -> Ordering)
-> (Uint32 -> Uint32 -> Bool)
-> (Uint32 -> Uint32 -> Bool)
-> (Uint32 -> Uint32 -> Bool)
-> (Uint32 -> Uint32 -> Bool)
-> (Uint32 -> Uint32 -> Uint32)
-> (Uint32 -> Uint32 -> Uint32)
-> Ord Uint32
Uint32 -> Uint32 -> Bool
Uint32 -> Uint32 -> Ordering
Uint32 -> Uint32 -> Uint32
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
$ccompare :: Uint32 -> Uint32 -> Ordering
compare :: Uint32 -> Uint32 -> Ordering
$c< :: Uint32 -> Uint32 -> Bool
< :: Uint32 -> Uint32 -> Bool
$c<= :: Uint32 -> Uint32 -> Bool
<= :: Uint32 -> Uint32 -> Bool
$c> :: Uint32 -> Uint32 -> Bool
> :: Uint32 -> Uint32 -> Bool
$c>= :: Uint32 -> Uint32 -> Bool
>= :: Uint32 -> Uint32 -> Bool
$cmax :: Uint32 -> Uint32 -> Uint32
max :: Uint32 -> Uint32 -> Uint32
$cmin :: Uint32 -> Uint32 -> Uint32
min :: Uint32 -> Uint32 -> Uint32
Ord, ReadPrec [Uint32]
ReadPrec Uint32
Int -> ReadS Uint32
ReadS [Uint32]
(Int -> ReadS Uint32)
-> ReadS [Uint32]
-> ReadPrec Uint32
-> ReadPrec [Uint32]
-> Read Uint32
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Uint32
readsPrec :: Int -> ReadS Uint32
$creadList :: ReadS [Uint32]
readList :: ReadS [Uint32]
$creadPrec :: ReadPrec Uint32
readPrec :: ReadPrec Uint32
$creadListPrec :: ReadPrec [Uint32]
readListPrec :: ReadPrec [Uint32]
Read, Int -> Uint32 -> ShowS
[Uint32] -> ShowS
Uint32 -> String
(Int -> Uint32 -> ShowS)
-> (Uint32 -> String) -> ([Uint32] -> ShowS) -> Show Uint32
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Uint32 -> ShowS
showsPrec :: Int -> Uint32 -> ShowS
$cshow :: Uint32 -> String
show :: Uint32 -> String
$cshowList :: [Uint32] -> ShowS
showList :: [Uint32] -> ShowS
Show)
  deriving newtype
    ( Word64 -> Int -> Uint32
Uint32 -> Int -> Word64
(Uint32 -> Int -> Word64)
-> (Word64 -> Int -> Uint32) -> Bitfield Uint32
forall a.
(a -> Int -> Word64) -> (Word64 -> Int -> a) -> Bitfield a
$cnarrow :: Uint32 -> Int -> Word64
narrow :: Uint32 -> Int -> Word64
$cextend :: Word64 -> Int -> Uint32
extend :: Word64 -> Int -> Uint32
BG.Bitfield
    , Eq Uint32
Uint32
Eq Uint32 =>
(Uint32 -> Uint32 -> Uint32)
-> (Uint32 -> Uint32 -> Uint32)
-> (Uint32 -> Uint32 -> Uint32)
-> (Uint32 -> Uint32)
-> (Uint32 -> Int -> Uint32)
-> (Uint32 -> Int -> Uint32)
-> Uint32
-> (Int -> Uint32)
-> (Uint32 -> Int -> Uint32)
-> (Uint32 -> Int -> Uint32)
-> (Uint32 -> Int -> Uint32)
-> (Uint32 -> Int -> Bool)
-> (Uint32 -> Maybe Int)
-> (Uint32 -> Int)
-> (Uint32 -> Bool)
-> (Uint32 -> Int -> Uint32)
-> (Uint32 -> Int -> Uint32)
-> (Uint32 -> Int -> Uint32)
-> (Uint32 -> Int -> Uint32)
-> (Uint32 -> Int -> Uint32)
-> (Uint32 -> Int -> Uint32)
-> (Uint32 -> Int)
-> Bits Uint32
Int -> Uint32
Uint32 -> Bool
Uint32 -> Int
Uint32 -> Maybe Int
Uint32 -> Uint32
Uint32 -> Int -> Bool
Uint32 -> Int -> Uint32
Uint32 -> Uint32 -> Uint32
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
$c.&. :: Uint32 -> Uint32 -> Uint32
.&. :: Uint32 -> Uint32 -> Uint32
$c.|. :: Uint32 -> Uint32 -> Uint32
.|. :: Uint32 -> Uint32 -> Uint32
$cxor :: Uint32 -> Uint32 -> Uint32
xor :: Uint32 -> Uint32 -> Uint32
$ccomplement :: Uint32 -> Uint32
complement :: Uint32 -> Uint32
$cshift :: Uint32 -> Int -> Uint32
shift :: Uint32 -> Int -> Uint32
$crotate :: Uint32 -> Int -> Uint32
rotate :: Uint32 -> Int -> Uint32
$czeroBits :: Uint32
zeroBits :: Uint32
$cbit :: Int -> Uint32
bit :: Int -> Uint32
$csetBit :: Uint32 -> Int -> Uint32
setBit :: Uint32 -> Int -> Uint32
$cclearBit :: Uint32 -> Int -> Uint32
clearBit :: Uint32 -> Int -> Uint32
$ccomplementBit :: Uint32 -> Int -> Uint32
complementBit :: Uint32 -> Int -> Uint32
$ctestBit :: Uint32 -> Int -> Bool
testBit :: Uint32 -> Int -> Bool
$cbitSizeMaybe :: Uint32 -> Maybe Int
bitSizeMaybe :: Uint32 -> Maybe Int
$cbitSize :: Uint32 -> Int
bitSize :: Uint32 -> Int
$cisSigned :: Uint32 -> Bool
isSigned :: Uint32 -> Bool
$cshiftL :: Uint32 -> Int -> Uint32
shiftL :: Uint32 -> Int -> Uint32
$cunsafeShiftL :: Uint32 -> Int -> Uint32
unsafeShiftL :: Uint32 -> Int -> Uint32
$cshiftR :: Uint32 -> Int -> Uint32
shiftR :: Uint32 -> Int -> Uint32
$cunsafeShiftR :: Uint32 -> Int -> Uint32
unsafeShiftR :: Uint32 -> Int -> Uint32
$crotateL :: Uint32 -> Int -> Uint32
rotateL :: Uint32 -> Int -> Uint32
$crotateR :: Uint32 -> Int -> Uint32
rotateR :: Uint32 -> Int -> Uint32
$cpopCount :: Uint32 -> Int
popCount :: Uint32 -> Int
BG.Bits
    , Bits Uint32
Bits Uint32 =>
(Uint32 -> Int)
-> (Uint32 -> Int) -> (Uint32 -> Int) -> FiniteBits Uint32
Uint32 -> Int
forall b.
Bits b =>
(b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
$cfiniteBitSize :: Uint32 -> Int
finiteBitSize :: Uint32 -> Int
$ccountLeadingZeros :: Uint32 -> Int
countLeadingZeros :: Uint32 -> Int
$ccountTrailingZeros :: Uint32 -> Int
countTrailingZeros :: Uint32 -> Int
BG.FiniteBits
    , FFIType Uint32 -> Uint32
Uint32 -> FFIType Uint32
(Uint32 -> FFIType Uint32)
-> (FFIType Uint32 -> Uint32) -> HasFFIType Uint32
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: Uint32 -> FFIType Uint32
toFFIType :: Uint32 -> FFIType Uint32
$cfromFFIType :: FFIType Uint32 -> Uint32
fromFFIType :: FFIType Uint32 -> Uint32
BG.HasFFIType
    , Ord Uint32
Ord Uint32 =>
((Uint32, Uint32) -> [Uint32])
-> ((Uint32, Uint32) -> Uint32 -> Int)
-> ((Uint32, Uint32) -> Uint32 -> Int)
-> ((Uint32, Uint32) -> Uint32 -> Bool)
-> ((Uint32, Uint32) -> Int)
-> ((Uint32, Uint32) -> Int)
-> Ix Uint32
(Uint32, Uint32) -> Int
(Uint32, Uint32) -> [Uint32]
(Uint32, Uint32) -> Uint32 -> Bool
(Uint32, Uint32) -> Uint32 -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
$crange :: (Uint32, Uint32) -> [Uint32]
range :: (Uint32, Uint32) -> [Uint32]
$cindex :: (Uint32, Uint32) -> Uint32 -> Int
index :: (Uint32, Uint32) -> Uint32 -> Int
$cunsafeIndex :: (Uint32, Uint32) -> Uint32 -> Int
unsafeIndex :: (Uint32, Uint32) -> Uint32 -> Int
$cinRange :: (Uint32, Uint32) -> Uint32 -> Bool
inRange :: (Uint32, Uint32) -> Uint32 -> Bool
$crangeSize :: (Uint32, Uint32) -> Int
rangeSize :: (Uint32, Uint32) -> Int
$cunsafeRangeSize :: (Uint32, Uint32) -> Int
unsafeRangeSize :: (Uint32, Uint32) -> Int
BG.Ix
    , Addr# -> Int# -> Uint32
ByteArray# -> Int# -> Uint32
Proxy Uint32 -> Int#
Uint32 -> Int#
(Proxy Uint32 -> Int#)
-> (Uint32 -> Int#)
-> (Proxy Uint32 -> Int#)
-> (Uint32 -> Int#)
-> (ByteArray# -> Int# -> Uint32)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint32 #))
-> (forall s.
    MutableByteArray# s -> Int# -> Uint32 -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s
    -> Int# -> Int# -> Uint32 -> State# s -> State# s)
-> (Addr# -> Int# -> Uint32)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, Uint32 #))
-> (forall s. Addr# -> Int# -> Uint32 -> State# s -> State# s)
-> (forall s.
    Addr# -> Int# -> Int# -> Uint32 -> State# s -> State# s)
-> Prim Uint32
forall s. Addr# -> Int# -> Int# -> Uint32 -> State# s -> State# s
forall s. Addr# -> Int# -> State# s -> (# State# s, Uint32 #)
forall s. Addr# -> Int# -> Uint32 -> State# s -> State# s
forall s.
MutableByteArray# s
-> Int# -> Int# -> Uint32 -> State# s -> State# s
forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint32 #)
forall s.
MutableByteArray# s -> Int# -> Uint32 -> State# s -> State# s
forall a.
(Proxy a -> Int#)
-> (a -> Int#)
-> (Proxy a -> Int#)
-> (a -> Int#)
-> (ByteArray# -> Int# -> a)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, a #))
-> (forall s.
    MutableByteArray# s -> Int# -> a -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s)
-> (Addr# -> Int# -> a)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, a #))
-> (forall s. Addr# -> Int# -> a -> State# s -> State# s)
-> (forall s. Addr# -> Int# -> Int# -> a -> State# s -> State# s)
-> Prim a
$csizeOfType# :: Proxy Uint32 -> Int#
sizeOfType# :: Proxy Uint32 -> Int#
$csizeOf# :: Uint32 -> Int#
sizeOf# :: Uint32 -> Int#
$calignmentOfType# :: Proxy Uint32 -> Int#
alignmentOfType# :: Proxy Uint32 -> Int#
$calignment# :: Uint32 -> Int#
alignment# :: Uint32 -> Int#
$cindexByteArray# :: ByteArray# -> Int# -> Uint32
indexByteArray# :: ByteArray# -> Int# -> Uint32
$creadByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint32 #)
readByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint32 #)
$cwriteByteArray# :: forall s.
MutableByteArray# s -> Int# -> Uint32 -> State# s -> State# s
writeByteArray# :: forall s.
MutableByteArray# s -> Int# -> Uint32 -> State# s -> State# s
$csetByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Uint32 -> State# s -> State# s
setByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Uint32 -> State# s -> State# s
$cindexOffAddr# :: Addr# -> Int# -> Uint32
indexOffAddr# :: Addr# -> Int# -> Uint32
$creadOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Uint32 #)
readOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Uint32 #)
$cwriteOffAddr# :: forall s. Addr# -> Int# -> Uint32 -> State# s -> State# s
writeOffAddr# :: forall s. Addr# -> Int# -> Uint32 -> State# s -> State# s
$csetOffAddr# :: forall s. Addr# -> Int# -> Int# -> Uint32 -> State# s -> State# s
setOffAddr# :: forall s. Addr# -> Int# -> Int# -> Uint32 -> State# s -> State# s
BG.Prim
    , Ptr Uint32 -> IO Uint32
Ptr Uint32 -> Int -> IO Uint32
Ptr Uint32 -> Int -> Uint32 -> IO ()
Ptr Uint32 -> Uint32 -> IO ()
Uint32 -> Int
(Uint32 -> Int)
-> (Uint32 -> Int)
-> (Ptr Uint32 -> Int -> IO Uint32)
-> (Ptr Uint32 -> Int -> Uint32 -> IO ())
-> (forall b. Ptr b -> Int -> IO Uint32)
-> (forall b. Ptr b -> Int -> Uint32 -> IO ())
-> (Ptr Uint32 -> IO Uint32)
-> (Ptr Uint32 -> Uint32 -> IO ())
-> Storable Uint32
forall b. Ptr b -> Int -> IO Uint32
forall b. Ptr b -> Int -> Uint32 -> 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
$csizeOf :: Uint32 -> Int
sizeOf :: Uint32 -> Int
$calignment :: Uint32 -> Int
alignment :: Uint32 -> Int
$cpeekElemOff :: Ptr Uint32 -> Int -> IO Uint32
peekElemOff :: Ptr Uint32 -> Int -> IO Uint32
$cpokeElemOff :: Ptr Uint32 -> Int -> Uint32 -> IO ()
pokeElemOff :: Ptr Uint32 -> Int -> Uint32 -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Uint32
peekByteOff :: forall b. Ptr b -> Int -> IO Uint32
$cpokeByteOff :: forall b. Ptr b -> Int -> Uint32 -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> Uint32 -> IO ()
$cpeek :: Ptr Uint32 -> IO Uint32
peek :: Ptr Uint32 -> IO Uint32
$cpoke :: Ptr Uint32 -> Uint32 -> IO ()
poke :: Ptr Uint32 -> Uint32 -> IO ()
BG.Storable
    , Uint32
Uint32 -> Uint32 -> Bounded Uint32
forall a. a -> a -> Bounded a
$cminBound :: Uint32
minBound :: Uint32
$cmaxBound :: Uint32
maxBound :: Uint32
Bounded
    , Int -> Uint32
Uint32 -> Int
Uint32 -> [Uint32]
Uint32 -> Uint32
Uint32 -> Uint32 -> [Uint32]
Uint32 -> Uint32 -> Uint32 -> [Uint32]
(Uint32 -> Uint32)
-> (Uint32 -> Uint32)
-> (Int -> Uint32)
-> (Uint32 -> Int)
-> (Uint32 -> [Uint32])
-> (Uint32 -> Uint32 -> [Uint32])
-> (Uint32 -> Uint32 -> [Uint32])
-> (Uint32 -> Uint32 -> Uint32 -> [Uint32])
-> Enum Uint32
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Uint32 -> Uint32
succ :: Uint32 -> Uint32
$cpred :: Uint32 -> Uint32
pred :: Uint32 -> Uint32
$ctoEnum :: Int -> Uint32
toEnum :: Int -> Uint32
$cfromEnum :: Uint32 -> Int
fromEnum :: Uint32 -> Int
$cenumFrom :: Uint32 -> [Uint32]
enumFrom :: Uint32 -> [Uint32]
$cenumFromThen :: Uint32 -> Uint32 -> [Uint32]
enumFromThen :: Uint32 -> Uint32 -> [Uint32]
$cenumFromTo :: Uint32 -> Uint32 -> [Uint32]
enumFromTo :: Uint32 -> Uint32 -> [Uint32]
$cenumFromThenTo :: Uint32 -> Uint32 -> Uint32 -> [Uint32]
enumFromThenTo :: Uint32 -> Uint32 -> Uint32 -> [Uint32]
Enum
    , Enum Uint32
Real Uint32
(Real Uint32, Enum Uint32) =>
(Uint32 -> Uint32 -> Uint32)
-> (Uint32 -> Uint32 -> Uint32)
-> (Uint32 -> Uint32 -> Uint32)
-> (Uint32 -> Uint32 -> Uint32)
-> (Uint32 -> Uint32 -> (Uint32, Uint32))
-> (Uint32 -> Uint32 -> (Uint32, Uint32))
-> (Uint32 -> Integer)
-> Integral Uint32
Uint32 -> Integer
Uint32 -> Uint32 -> (Uint32, Uint32)
Uint32 -> Uint32 -> Uint32
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
$cquot :: Uint32 -> Uint32 -> Uint32
quot :: Uint32 -> Uint32 -> Uint32
$crem :: Uint32 -> Uint32 -> Uint32
rem :: Uint32 -> Uint32 -> Uint32
$cdiv :: Uint32 -> Uint32 -> Uint32
div :: Uint32 -> Uint32 -> Uint32
$cmod :: Uint32 -> Uint32 -> Uint32
mod :: Uint32 -> Uint32 -> Uint32
$cquotRem :: Uint32 -> Uint32 -> (Uint32, Uint32)
quotRem :: Uint32 -> Uint32 -> (Uint32, Uint32)
$cdivMod :: Uint32 -> Uint32 -> (Uint32, Uint32)
divMod :: Uint32 -> Uint32 -> (Uint32, Uint32)
$ctoInteger :: Uint32 -> Integer
toInteger :: Uint32 -> Integer
Integral
    , Ptr Uint32 -> IO Uint32
(Ptr Uint32 -> IO Uint32) -> ReadRaw Uint32
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr Uint32 -> IO Uint32
readRaw :: Ptr Uint32 -> IO Uint32
Marshal.ReadRaw
    , Proxy Uint32 -> Int
(Proxy Uint32 -> Int) -> (Proxy Uint32 -> Int) -> StaticSize Uint32
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy Uint32 -> Int
staticSizeOf :: Proxy Uint32 -> Int
$cstaticAlignment :: Proxy Uint32 -> Int
staticAlignment :: Proxy Uint32 -> Int
Marshal.StaticSize
    , Ptr Uint32 -> Uint32 -> IO ()
(Ptr Uint32 -> Uint32 -> IO ()) -> WriteRaw Uint32
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr Uint32 -> Uint32 -> IO ()
writeRaw :: Ptr Uint32 -> Uint32 -> IO ()
Marshal.WriteRaw
    , Integer -> Uint32
Uint32 -> Uint32
Uint32 -> Uint32 -> Uint32
(Uint32 -> Uint32 -> Uint32)
-> (Uint32 -> Uint32 -> Uint32)
-> (Uint32 -> Uint32 -> Uint32)
-> (Uint32 -> Uint32)
-> (Uint32 -> Uint32)
-> (Uint32 -> Uint32)
-> (Integer -> Uint32)
-> Num Uint32
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Uint32 -> Uint32 -> Uint32
+ :: Uint32 -> Uint32 -> Uint32
$c- :: Uint32 -> Uint32 -> Uint32
- :: Uint32 -> Uint32 -> Uint32
$c* :: Uint32 -> Uint32 -> Uint32
* :: Uint32 -> Uint32 -> Uint32
$cnegate :: Uint32 -> Uint32
negate :: Uint32 -> Uint32
$cabs :: Uint32 -> Uint32
abs :: Uint32 -> Uint32
$csignum :: Uint32 -> Uint32
signum :: Uint32 -> Uint32
$cfromInteger :: Integer -> Uint32
fromInteger :: Integer -> Uint32
Num
    , Num Uint32
Ord Uint32
(Num Uint32, Ord Uint32) => (Uint32 -> Rational) -> Real Uint32
Uint32 -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Uint32 -> Rational
toRational :: Uint32 -> Rational
Real
    )

instance
  (ty ~ HsBindgen.Runtime.LibC.Word32)
  => BG.CompatHasField.HasField "unwrap" Uint32 ty
  where
  hasField :: Uint32 -> (ty -> Uint32, ty)
hasField =
    \Uint32
x0 ->
      ( \ty
y1 ->
          Uint32{unwrap :: Word32
unwrap = ty
Word32
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" Uint32
x0
      )

instance
  (ty ~ HsBindgen.Runtime.LibC.Word32)
  => BG.HasField "unwrap" (BG.Ptr Uint32) (BG.Ptr ty)
  where
  getField :: Ptr Uint32 -> Ptr ty
getField = Proxy "unwrap" -> Ptr Uint32 -> Ptr (CFieldType Uint32 "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField Uint32 "unwrap" where
  type
    CFieldType Uint32 "unwrap" =
      HsBindgen.Runtime.LibC.Word32

  offset# :: Proxy# Uint32 -> Proxy# "unwrap" -> Int
offset# = \Proxy# Uint32
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | A signed 64-bit integer type.
--
--     @since 3.2.0
--
--     [See also]: @SDL_SINT64_C@
--
--     [C declaration]: @Sint64@, defined at @SDL3\/SDL_stdinc.h 493:17@
newtype Sint64 = Sint64
  { Sint64 -> Int64
unwrap :: HsBindgen.Runtime.LibC.Int64
  }
  deriving stock ((forall x. Sint64 -> Rep Sint64 x)
-> (forall x. Rep Sint64 x -> Sint64) -> Generic Sint64
forall x. Rep Sint64 x -> Sint64
forall x. Sint64 -> Rep Sint64 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Sint64 -> Rep Sint64 x
from :: forall x. Sint64 -> Rep Sint64 x
$cto :: forall x. Rep Sint64 x -> Sint64
to :: forall x. Rep Sint64 x -> Sint64
BG.Generic, Sint64 -> Sint64 -> Bool
(Sint64 -> Sint64 -> Bool)
-> (Sint64 -> Sint64 -> Bool) -> Eq Sint64
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Sint64 -> Sint64 -> Bool
== :: Sint64 -> Sint64 -> Bool
$c/= :: Sint64 -> Sint64 -> Bool
/= :: Sint64 -> Sint64 -> Bool
Eq, Eq Sint64
Eq Sint64 =>
(Sint64 -> Sint64 -> Ordering)
-> (Sint64 -> Sint64 -> Bool)
-> (Sint64 -> Sint64 -> Bool)
-> (Sint64 -> Sint64 -> Bool)
-> (Sint64 -> Sint64 -> Bool)
-> (Sint64 -> Sint64 -> Sint64)
-> (Sint64 -> Sint64 -> Sint64)
-> Ord Sint64
Sint64 -> Sint64 -> Bool
Sint64 -> Sint64 -> Ordering
Sint64 -> Sint64 -> Sint64
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
$ccompare :: Sint64 -> Sint64 -> Ordering
compare :: Sint64 -> Sint64 -> Ordering
$c< :: Sint64 -> Sint64 -> Bool
< :: Sint64 -> Sint64 -> Bool
$c<= :: Sint64 -> Sint64 -> Bool
<= :: Sint64 -> Sint64 -> Bool
$c> :: Sint64 -> Sint64 -> Bool
> :: Sint64 -> Sint64 -> Bool
$c>= :: Sint64 -> Sint64 -> Bool
>= :: Sint64 -> Sint64 -> Bool
$cmax :: Sint64 -> Sint64 -> Sint64
max :: Sint64 -> Sint64 -> Sint64
$cmin :: Sint64 -> Sint64 -> Sint64
min :: Sint64 -> Sint64 -> Sint64
Ord, ReadPrec [Sint64]
ReadPrec Sint64
Int -> ReadS Sint64
ReadS [Sint64]
(Int -> ReadS Sint64)
-> ReadS [Sint64]
-> ReadPrec Sint64
-> ReadPrec [Sint64]
-> Read Sint64
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Sint64
readsPrec :: Int -> ReadS Sint64
$creadList :: ReadS [Sint64]
readList :: ReadS [Sint64]
$creadPrec :: ReadPrec Sint64
readPrec :: ReadPrec Sint64
$creadListPrec :: ReadPrec [Sint64]
readListPrec :: ReadPrec [Sint64]
Read, Int -> Sint64 -> ShowS
[Sint64] -> ShowS
Sint64 -> String
(Int -> Sint64 -> ShowS)
-> (Sint64 -> String) -> ([Sint64] -> ShowS) -> Show Sint64
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Sint64 -> ShowS
showsPrec :: Int -> Sint64 -> ShowS
$cshow :: Sint64 -> String
show :: Sint64 -> String
$cshowList :: [Sint64] -> ShowS
showList :: [Sint64] -> ShowS
Show)
  deriving newtype
    ( Word64 -> Int -> Sint64
Sint64 -> Int -> Word64
(Sint64 -> Int -> Word64)
-> (Word64 -> Int -> Sint64) -> Bitfield Sint64
forall a.
(a -> Int -> Word64) -> (Word64 -> Int -> a) -> Bitfield a
$cnarrow :: Sint64 -> Int -> Word64
narrow :: Sint64 -> Int -> Word64
$cextend :: Word64 -> Int -> Sint64
extend :: Word64 -> Int -> Sint64
BG.Bitfield
    , Eq Sint64
Sint64
Eq Sint64 =>
(Sint64 -> Sint64 -> Sint64)
-> (Sint64 -> Sint64 -> Sint64)
-> (Sint64 -> Sint64 -> Sint64)
-> (Sint64 -> Sint64)
-> (Sint64 -> Int -> Sint64)
-> (Sint64 -> Int -> Sint64)
-> Sint64
-> (Int -> Sint64)
-> (Sint64 -> Int -> Sint64)
-> (Sint64 -> Int -> Sint64)
-> (Sint64 -> Int -> Sint64)
-> (Sint64 -> Int -> Bool)
-> (Sint64 -> Maybe Int)
-> (Sint64 -> Int)
-> (Sint64 -> Bool)
-> (Sint64 -> Int -> Sint64)
-> (Sint64 -> Int -> Sint64)
-> (Sint64 -> Int -> Sint64)
-> (Sint64 -> Int -> Sint64)
-> (Sint64 -> Int -> Sint64)
-> (Sint64 -> Int -> Sint64)
-> (Sint64 -> Int)
-> Bits Sint64
Int -> Sint64
Sint64 -> Bool
Sint64 -> Int
Sint64 -> Maybe Int
Sint64 -> Sint64
Sint64 -> Int -> Bool
Sint64 -> Int -> Sint64
Sint64 -> Sint64 -> Sint64
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
$c.&. :: Sint64 -> Sint64 -> Sint64
.&. :: Sint64 -> Sint64 -> Sint64
$c.|. :: Sint64 -> Sint64 -> Sint64
.|. :: Sint64 -> Sint64 -> Sint64
$cxor :: Sint64 -> Sint64 -> Sint64
xor :: Sint64 -> Sint64 -> Sint64
$ccomplement :: Sint64 -> Sint64
complement :: Sint64 -> Sint64
$cshift :: Sint64 -> Int -> Sint64
shift :: Sint64 -> Int -> Sint64
$crotate :: Sint64 -> Int -> Sint64
rotate :: Sint64 -> Int -> Sint64
$czeroBits :: Sint64
zeroBits :: Sint64
$cbit :: Int -> Sint64
bit :: Int -> Sint64
$csetBit :: Sint64 -> Int -> Sint64
setBit :: Sint64 -> Int -> Sint64
$cclearBit :: Sint64 -> Int -> Sint64
clearBit :: Sint64 -> Int -> Sint64
$ccomplementBit :: Sint64 -> Int -> Sint64
complementBit :: Sint64 -> Int -> Sint64
$ctestBit :: Sint64 -> Int -> Bool
testBit :: Sint64 -> Int -> Bool
$cbitSizeMaybe :: Sint64 -> Maybe Int
bitSizeMaybe :: Sint64 -> Maybe Int
$cbitSize :: Sint64 -> Int
bitSize :: Sint64 -> Int
$cisSigned :: Sint64 -> Bool
isSigned :: Sint64 -> Bool
$cshiftL :: Sint64 -> Int -> Sint64
shiftL :: Sint64 -> Int -> Sint64
$cunsafeShiftL :: Sint64 -> Int -> Sint64
unsafeShiftL :: Sint64 -> Int -> Sint64
$cshiftR :: Sint64 -> Int -> Sint64
shiftR :: Sint64 -> Int -> Sint64
$cunsafeShiftR :: Sint64 -> Int -> Sint64
unsafeShiftR :: Sint64 -> Int -> Sint64
$crotateL :: Sint64 -> Int -> Sint64
rotateL :: Sint64 -> Int -> Sint64
$crotateR :: Sint64 -> Int -> Sint64
rotateR :: Sint64 -> Int -> Sint64
$cpopCount :: Sint64 -> Int
popCount :: Sint64 -> Int
BG.Bits
    , Bits Sint64
Bits Sint64 =>
(Sint64 -> Int)
-> (Sint64 -> Int) -> (Sint64 -> Int) -> FiniteBits Sint64
Sint64 -> Int
forall b.
Bits b =>
(b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
$cfiniteBitSize :: Sint64 -> Int
finiteBitSize :: Sint64 -> Int
$ccountLeadingZeros :: Sint64 -> Int
countLeadingZeros :: Sint64 -> Int
$ccountTrailingZeros :: Sint64 -> Int
countTrailingZeros :: Sint64 -> Int
BG.FiniteBits
    , FFIType Sint64 -> Sint64
Sint64 -> FFIType Sint64
(Sint64 -> FFIType Sint64)
-> (FFIType Sint64 -> Sint64) -> HasFFIType Sint64
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: Sint64 -> FFIType Sint64
toFFIType :: Sint64 -> FFIType Sint64
$cfromFFIType :: FFIType Sint64 -> Sint64
fromFFIType :: FFIType Sint64 -> Sint64
BG.HasFFIType
    , Ord Sint64
Ord Sint64 =>
((Sint64, Sint64) -> [Sint64])
-> ((Sint64, Sint64) -> Sint64 -> Int)
-> ((Sint64, Sint64) -> Sint64 -> Int)
-> ((Sint64, Sint64) -> Sint64 -> Bool)
-> ((Sint64, Sint64) -> Int)
-> ((Sint64, Sint64) -> Int)
-> Ix Sint64
(Sint64, Sint64) -> Int
(Sint64, Sint64) -> [Sint64]
(Sint64, Sint64) -> Sint64 -> Bool
(Sint64, Sint64) -> Sint64 -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
$crange :: (Sint64, Sint64) -> [Sint64]
range :: (Sint64, Sint64) -> [Sint64]
$cindex :: (Sint64, Sint64) -> Sint64 -> Int
index :: (Sint64, Sint64) -> Sint64 -> Int
$cunsafeIndex :: (Sint64, Sint64) -> Sint64 -> Int
unsafeIndex :: (Sint64, Sint64) -> Sint64 -> Int
$cinRange :: (Sint64, Sint64) -> Sint64 -> Bool
inRange :: (Sint64, Sint64) -> Sint64 -> Bool
$crangeSize :: (Sint64, Sint64) -> Int
rangeSize :: (Sint64, Sint64) -> Int
$cunsafeRangeSize :: (Sint64, Sint64) -> Int
unsafeRangeSize :: (Sint64, Sint64) -> Int
BG.Ix
    , Addr# -> Int# -> Sint64
ByteArray# -> Int# -> Sint64
Proxy Sint64 -> Int#
Sint64 -> Int#
(Proxy Sint64 -> Int#)
-> (Sint64 -> Int#)
-> (Proxy Sint64 -> Int#)
-> (Sint64 -> Int#)
-> (ByteArray# -> Int# -> Sint64)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint64 #))
-> (forall s.
    MutableByteArray# s -> Int# -> Sint64 -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s
    -> Int# -> Int# -> Sint64 -> State# s -> State# s)
-> (Addr# -> Int# -> Sint64)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, Sint64 #))
-> (forall s. Addr# -> Int# -> Sint64 -> State# s -> State# s)
-> (forall s.
    Addr# -> Int# -> Int# -> Sint64 -> State# s -> State# s)
-> Prim Sint64
forall s. Addr# -> Int# -> Int# -> Sint64 -> State# s -> State# s
forall s. Addr# -> Int# -> State# s -> (# State# s, Sint64 #)
forall s. Addr# -> Int# -> Sint64 -> State# s -> State# s
forall s.
MutableByteArray# s
-> Int# -> Int# -> Sint64 -> State# s -> State# s
forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint64 #)
forall s.
MutableByteArray# s -> Int# -> Sint64 -> State# s -> State# s
forall a.
(Proxy a -> Int#)
-> (a -> Int#)
-> (Proxy a -> Int#)
-> (a -> Int#)
-> (ByteArray# -> Int# -> a)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, a #))
-> (forall s.
    MutableByteArray# s -> Int# -> a -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s)
-> (Addr# -> Int# -> a)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, a #))
-> (forall s. Addr# -> Int# -> a -> State# s -> State# s)
-> (forall s. Addr# -> Int# -> Int# -> a -> State# s -> State# s)
-> Prim a
$csizeOfType# :: Proxy Sint64 -> Int#
sizeOfType# :: Proxy Sint64 -> Int#
$csizeOf# :: Sint64 -> Int#
sizeOf# :: Sint64 -> Int#
$calignmentOfType# :: Proxy Sint64 -> Int#
alignmentOfType# :: Proxy Sint64 -> Int#
$calignment# :: Sint64 -> Int#
alignment# :: Sint64 -> Int#
$cindexByteArray# :: ByteArray# -> Int# -> Sint64
indexByteArray# :: ByteArray# -> Int# -> Sint64
$creadByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint64 #)
readByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Sint64 #)
$cwriteByteArray# :: forall s.
MutableByteArray# s -> Int# -> Sint64 -> State# s -> State# s
writeByteArray# :: forall s.
MutableByteArray# s -> Int# -> Sint64 -> State# s -> State# s
$csetByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Sint64 -> State# s -> State# s
setByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Sint64 -> State# s -> State# s
$cindexOffAddr# :: Addr# -> Int# -> Sint64
indexOffAddr# :: Addr# -> Int# -> Sint64
$creadOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Sint64 #)
readOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Sint64 #)
$cwriteOffAddr# :: forall s. Addr# -> Int# -> Sint64 -> State# s -> State# s
writeOffAddr# :: forall s. Addr# -> Int# -> Sint64 -> State# s -> State# s
$csetOffAddr# :: forall s. Addr# -> Int# -> Int# -> Sint64 -> State# s -> State# s
setOffAddr# :: forall s. Addr# -> Int# -> Int# -> Sint64 -> State# s -> State# s
BG.Prim
    , Ptr Sint64 -> IO Sint64
Ptr Sint64 -> Int -> IO Sint64
Ptr Sint64 -> Int -> Sint64 -> IO ()
Ptr Sint64 -> Sint64 -> IO ()
Sint64 -> Int
(Sint64 -> Int)
-> (Sint64 -> Int)
-> (Ptr Sint64 -> Int -> IO Sint64)
-> (Ptr Sint64 -> Int -> Sint64 -> IO ())
-> (forall b. Ptr b -> Int -> IO Sint64)
-> (forall b. Ptr b -> Int -> Sint64 -> IO ())
-> (Ptr Sint64 -> IO Sint64)
-> (Ptr Sint64 -> Sint64 -> IO ())
-> Storable Sint64
forall b. Ptr b -> Int -> IO Sint64
forall b. Ptr b -> Int -> Sint64 -> 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
$csizeOf :: Sint64 -> Int
sizeOf :: Sint64 -> Int
$calignment :: Sint64 -> Int
alignment :: Sint64 -> Int
$cpeekElemOff :: Ptr Sint64 -> Int -> IO Sint64
peekElemOff :: Ptr Sint64 -> Int -> IO Sint64
$cpokeElemOff :: Ptr Sint64 -> Int -> Sint64 -> IO ()
pokeElemOff :: Ptr Sint64 -> Int -> Sint64 -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Sint64
peekByteOff :: forall b. Ptr b -> Int -> IO Sint64
$cpokeByteOff :: forall b. Ptr b -> Int -> Sint64 -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> Sint64 -> IO ()
$cpeek :: Ptr Sint64 -> IO Sint64
peek :: Ptr Sint64 -> IO Sint64
$cpoke :: Ptr Sint64 -> Sint64 -> IO ()
poke :: Ptr Sint64 -> Sint64 -> IO ()
BG.Storable
    , Sint64
Sint64 -> Sint64 -> Bounded Sint64
forall a. a -> a -> Bounded a
$cminBound :: Sint64
minBound :: Sint64
$cmaxBound :: Sint64
maxBound :: Sint64
Bounded
    , Int -> Sint64
Sint64 -> Int
Sint64 -> [Sint64]
Sint64 -> Sint64
Sint64 -> Sint64 -> [Sint64]
Sint64 -> Sint64 -> Sint64 -> [Sint64]
(Sint64 -> Sint64)
-> (Sint64 -> Sint64)
-> (Int -> Sint64)
-> (Sint64 -> Int)
-> (Sint64 -> [Sint64])
-> (Sint64 -> Sint64 -> [Sint64])
-> (Sint64 -> Sint64 -> [Sint64])
-> (Sint64 -> Sint64 -> Sint64 -> [Sint64])
-> Enum Sint64
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Sint64 -> Sint64
succ :: Sint64 -> Sint64
$cpred :: Sint64 -> Sint64
pred :: Sint64 -> Sint64
$ctoEnum :: Int -> Sint64
toEnum :: Int -> Sint64
$cfromEnum :: Sint64 -> Int
fromEnum :: Sint64 -> Int
$cenumFrom :: Sint64 -> [Sint64]
enumFrom :: Sint64 -> [Sint64]
$cenumFromThen :: Sint64 -> Sint64 -> [Sint64]
enumFromThen :: Sint64 -> Sint64 -> [Sint64]
$cenumFromTo :: Sint64 -> Sint64 -> [Sint64]
enumFromTo :: Sint64 -> Sint64 -> [Sint64]
$cenumFromThenTo :: Sint64 -> Sint64 -> Sint64 -> [Sint64]
enumFromThenTo :: Sint64 -> Sint64 -> Sint64 -> [Sint64]
Enum
    , Enum Sint64
Real Sint64
(Real Sint64, Enum Sint64) =>
(Sint64 -> Sint64 -> Sint64)
-> (Sint64 -> Sint64 -> Sint64)
-> (Sint64 -> Sint64 -> Sint64)
-> (Sint64 -> Sint64 -> Sint64)
-> (Sint64 -> Sint64 -> (Sint64, Sint64))
-> (Sint64 -> Sint64 -> (Sint64, Sint64))
-> (Sint64 -> Integer)
-> Integral Sint64
Sint64 -> Integer
Sint64 -> Sint64 -> (Sint64, Sint64)
Sint64 -> Sint64 -> Sint64
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
$cquot :: Sint64 -> Sint64 -> Sint64
quot :: Sint64 -> Sint64 -> Sint64
$crem :: Sint64 -> Sint64 -> Sint64
rem :: Sint64 -> Sint64 -> Sint64
$cdiv :: Sint64 -> Sint64 -> Sint64
div :: Sint64 -> Sint64 -> Sint64
$cmod :: Sint64 -> Sint64 -> Sint64
mod :: Sint64 -> Sint64 -> Sint64
$cquotRem :: Sint64 -> Sint64 -> (Sint64, Sint64)
quotRem :: Sint64 -> Sint64 -> (Sint64, Sint64)
$cdivMod :: Sint64 -> Sint64 -> (Sint64, Sint64)
divMod :: Sint64 -> Sint64 -> (Sint64, Sint64)
$ctoInteger :: Sint64 -> Integer
toInteger :: Sint64 -> Integer
Integral
    , Ptr Sint64 -> IO Sint64
(Ptr Sint64 -> IO Sint64) -> ReadRaw Sint64
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr Sint64 -> IO Sint64
readRaw :: Ptr Sint64 -> IO Sint64
Marshal.ReadRaw
    , Proxy Sint64 -> Int
(Proxy Sint64 -> Int) -> (Proxy Sint64 -> Int) -> StaticSize Sint64
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy Sint64 -> Int
staticSizeOf :: Proxy Sint64 -> Int
$cstaticAlignment :: Proxy Sint64 -> Int
staticAlignment :: Proxy Sint64 -> Int
Marshal.StaticSize
    , Ptr Sint64 -> Sint64 -> IO ()
(Ptr Sint64 -> Sint64 -> IO ()) -> WriteRaw Sint64
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr Sint64 -> Sint64 -> IO ()
writeRaw :: Ptr Sint64 -> Sint64 -> IO ()
Marshal.WriteRaw
    , Integer -> Sint64
Sint64 -> Sint64
Sint64 -> Sint64 -> Sint64
(Sint64 -> Sint64 -> Sint64)
-> (Sint64 -> Sint64 -> Sint64)
-> (Sint64 -> Sint64 -> Sint64)
-> (Sint64 -> Sint64)
-> (Sint64 -> Sint64)
-> (Sint64 -> Sint64)
-> (Integer -> Sint64)
-> Num Sint64
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Sint64 -> Sint64 -> Sint64
+ :: Sint64 -> Sint64 -> Sint64
$c- :: Sint64 -> Sint64 -> Sint64
- :: Sint64 -> Sint64 -> Sint64
$c* :: Sint64 -> Sint64 -> Sint64
* :: Sint64 -> Sint64 -> Sint64
$cnegate :: Sint64 -> Sint64
negate :: Sint64 -> Sint64
$cabs :: Sint64 -> Sint64
abs :: Sint64 -> Sint64
$csignum :: Sint64 -> Sint64
signum :: Sint64 -> Sint64
$cfromInteger :: Integer -> Sint64
fromInteger :: Integer -> Sint64
Num
    , Num Sint64
Ord Sint64
(Num Sint64, Ord Sint64) => (Sint64 -> Rational) -> Real Sint64
Sint64 -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Sint64 -> Rational
toRational :: Sint64 -> Rational
Real
    )

instance
  (ty ~ HsBindgen.Runtime.LibC.Int64)
  => BG.CompatHasField.HasField "unwrap" Sint64 ty
  where
  hasField :: Sint64 -> (ty -> Sint64, ty)
hasField =
    \Sint64
x0 ->
      ( \ty
y1 ->
          Sint64{unwrap :: Int64
unwrap = ty
Int64
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" Sint64
x0
      )

instance
  (ty ~ HsBindgen.Runtime.LibC.Int64)
  => BG.HasField "unwrap" (BG.Ptr Sint64) (BG.Ptr ty)
  where
  getField :: Ptr Sint64 -> Ptr ty
getField = Proxy "unwrap" -> Ptr Sint64 -> Ptr (CFieldType Sint64 "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField Sint64 "unwrap" where
  type
    CFieldType Sint64 "unwrap" =
      HsBindgen.Runtime.LibC.Int64

  offset# :: Proxy# Sint64 -> Proxy# "unwrap" -> Int
offset# = \Proxy# Sint64
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | An unsigned 64-bit integer type.
--
--     @since 3.2.0
--
--     [See also]: @SDL_UINT64_C@
--
--     [C declaration]: @Uint64@, defined at @SDL3\/SDL_stdinc.h 504:18@
newtype Uint64 = Uint64
  { Uint64 -> Word64
unwrap :: HsBindgen.Runtime.LibC.Word64
  }
  deriving stock ((forall x. Uint64 -> Rep Uint64 x)
-> (forall x. Rep Uint64 x -> Uint64) -> Generic Uint64
forall x. Rep Uint64 x -> Uint64
forall x. Uint64 -> Rep Uint64 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Uint64 -> Rep Uint64 x
from :: forall x. Uint64 -> Rep Uint64 x
$cto :: forall x. Rep Uint64 x -> Uint64
to :: forall x. Rep Uint64 x -> Uint64
BG.Generic, Uint64 -> Uint64 -> Bool
(Uint64 -> Uint64 -> Bool)
-> (Uint64 -> Uint64 -> Bool) -> Eq Uint64
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Uint64 -> Uint64 -> Bool
== :: Uint64 -> Uint64 -> Bool
$c/= :: Uint64 -> Uint64 -> Bool
/= :: Uint64 -> Uint64 -> Bool
Eq, Eq Uint64
Eq Uint64 =>
(Uint64 -> Uint64 -> Ordering)
-> (Uint64 -> Uint64 -> Bool)
-> (Uint64 -> Uint64 -> Bool)
-> (Uint64 -> Uint64 -> Bool)
-> (Uint64 -> Uint64 -> Bool)
-> (Uint64 -> Uint64 -> Uint64)
-> (Uint64 -> Uint64 -> Uint64)
-> Ord Uint64
Uint64 -> Uint64 -> Bool
Uint64 -> Uint64 -> Ordering
Uint64 -> Uint64 -> Uint64
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
$ccompare :: Uint64 -> Uint64 -> Ordering
compare :: Uint64 -> Uint64 -> Ordering
$c< :: Uint64 -> Uint64 -> Bool
< :: Uint64 -> Uint64 -> Bool
$c<= :: Uint64 -> Uint64 -> Bool
<= :: Uint64 -> Uint64 -> Bool
$c> :: Uint64 -> Uint64 -> Bool
> :: Uint64 -> Uint64 -> Bool
$c>= :: Uint64 -> Uint64 -> Bool
>= :: Uint64 -> Uint64 -> Bool
$cmax :: Uint64 -> Uint64 -> Uint64
max :: Uint64 -> Uint64 -> Uint64
$cmin :: Uint64 -> Uint64 -> Uint64
min :: Uint64 -> Uint64 -> Uint64
Ord, ReadPrec [Uint64]
ReadPrec Uint64
Int -> ReadS Uint64
ReadS [Uint64]
(Int -> ReadS Uint64)
-> ReadS [Uint64]
-> ReadPrec Uint64
-> ReadPrec [Uint64]
-> Read Uint64
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Uint64
readsPrec :: Int -> ReadS Uint64
$creadList :: ReadS [Uint64]
readList :: ReadS [Uint64]
$creadPrec :: ReadPrec Uint64
readPrec :: ReadPrec Uint64
$creadListPrec :: ReadPrec [Uint64]
readListPrec :: ReadPrec [Uint64]
Read, Int -> Uint64 -> ShowS
[Uint64] -> ShowS
Uint64 -> String
(Int -> Uint64 -> ShowS)
-> (Uint64 -> String) -> ([Uint64] -> ShowS) -> Show Uint64
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Uint64 -> ShowS
showsPrec :: Int -> Uint64 -> ShowS
$cshow :: Uint64 -> String
show :: Uint64 -> String
$cshowList :: [Uint64] -> ShowS
showList :: [Uint64] -> ShowS
Show)
  deriving newtype
    ( Word64 -> Int -> Uint64
Uint64 -> Int -> Word64
(Uint64 -> Int -> Word64)
-> (Word64 -> Int -> Uint64) -> Bitfield Uint64
forall a.
(a -> Int -> Word64) -> (Word64 -> Int -> a) -> Bitfield a
$cnarrow :: Uint64 -> Int -> Word64
narrow :: Uint64 -> Int -> Word64
$cextend :: Word64 -> Int -> Uint64
extend :: Word64 -> Int -> Uint64
BG.Bitfield
    , Eq Uint64
Uint64
Eq Uint64 =>
(Uint64 -> Uint64 -> Uint64)
-> (Uint64 -> Uint64 -> Uint64)
-> (Uint64 -> Uint64 -> Uint64)
-> (Uint64 -> Uint64)
-> (Uint64 -> Int -> Uint64)
-> (Uint64 -> Int -> Uint64)
-> Uint64
-> (Int -> Uint64)
-> (Uint64 -> Int -> Uint64)
-> (Uint64 -> Int -> Uint64)
-> (Uint64 -> Int -> Uint64)
-> (Uint64 -> Int -> Bool)
-> (Uint64 -> Maybe Int)
-> (Uint64 -> Int)
-> (Uint64 -> Bool)
-> (Uint64 -> Int -> Uint64)
-> (Uint64 -> Int -> Uint64)
-> (Uint64 -> Int -> Uint64)
-> (Uint64 -> Int -> Uint64)
-> (Uint64 -> Int -> Uint64)
-> (Uint64 -> Int -> Uint64)
-> (Uint64 -> Int)
-> Bits Uint64
Int -> Uint64
Uint64 -> Bool
Uint64 -> Int
Uint64 -> Maybe Int
Uint64 -> Uint64
Uint64 -> Int -> Bool
Uint64 -> Int -> Uint64
Uint64 -> Uint64 -> Uint64
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
$c.&. :: Uint64 -> Uint64 -> Uint64
.&. :: Uint64 -> Uint64 -> Uint64
$c.|. :: Uint64 -> Uint64 -> Uint64
.|. :: Uint64 -> Uint64 -> Uint64
$cxor :: Uint64 -> Uint64 -> Uint64
xor :: Uint64 -> Uint64 -> Uint64
$ccomplement :: Uint64 -> Uint64
complement :: Uint64 -> Uint64
$cshift :: Uint64 -> Int -> Uint64
shift :: Uint64 -> Int -> Uint64
$crotate :: Uint64 -> Int -> Uint64
rotate :: Uint64 -> Int -> Uint64
$czeroBits :: Uint64
zeroBits :: Uint64
$cbit :: Int -> Uint64
bit :: Int -> Uint64
$csetBit :: Uint64 -> Int -> Uint64
setBit :: Uint64 -> Int -> Uint64
$cclearBit :: Uint64 -> Int -> Uint64
clearBit :: Uint64 -> Int -> Uint64
$ccomplementBit :: Uint64 -> Int -> Uint64
complementBit :: Uint64 -> Int -> Uint64
$ctestBit :: Uint64 -> Int -> Bool
testBit :: Uint64 -> Int -> Bool
$cbitSizeMaybe :: Uint64 -> Maybe Int
bitSizeMaybe :: Uint64 -> Maybe Int
$cbitSize :: Uint64 -> Int
bitSize :: Uint64 -> Int
$cisSigned :: Uint64 -> Bool
isSigned :: Uint64 -> Bool
$cshiftL :: Uint64 -> Int -> Uint64
shiftL :: Uint64 -> Int -> Uint64
$cunsafeShiftL :: Uint64 -> Int -> Uint64
unsafeShiftL :: Uint64 -> Int -> Uint64
$cshiftR :: Uint64 -> Int -> Uint64
shiftR :: Uint64 -> Int -> Uint64
$cunsafeShiftR :: Uint64 -> Int -> Uint64
unsafeShiftR :: Uint64 -> Int -> Uint64
$crotateL :: Uint64 -> Int -> Uint64
rotateL :: Uint64 -> Int -> Uint64
$crotateR :: Uint64 -> Int -> Uint64
rotateR :: Uint64 -> Int -> Uint64
$cpopCount :: Uint64 -> Int
popCount :: Uint64 -> Int
BG.Bits
    , Bits Uint64
Bits Uint64 =>
(Uint64 -> Int)
-> (Uint64 -> Int) -> (Uint64 -> Int) -> FiniteBits Uint64
Uint64 -> Int
forall b.
Bits b =>
(b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
$cfiniteBitSize :: Uint64 -> Int
finiteBitSize :: Uint64 -> Int
$ccountLeadingZeros :: Uint64 -> Int
countLeadingZeros :: Uint64 -> Int
$ccountTrailingZeros :: Uint64 -> Int
countTrailingZeros :: Uint64 -> Int
BG.FiniteBits
    , FFIType Uint64 -> Uint64
Uint64 -> FFIType Uint64
(Uint64 -> FFIType Uint64)
-> (FFIType Uint64 -> Uint64) -> HasFFIType Uint64
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: Uint64 -> FFIType Uint64
toFFIType :: Uint64 -> FFIType Uint64
$cfromFFIType :: FFIType Uint64 -> Uint64
fromFFIType :: FFIType Uint64 -> Uint64
BG.HasFFIType
    , Ord Uint64
Ord Uint64 =>
((Uint64, Uint64) -> [Uint64])
-> ((Uint64, Uint64) -> Uint64 -> Int)
-> ((Uint64, Uint64) -> Uint64 -> Int)
-> ((Uint64, Uint64) -> Uint64 -> Bool)
-> ((Uint64, Uint64) -> Int)
-> ((Uint64, Uint64) -> Int)
-> Ix Uint64
(Uint64, Uint64) -> Int
(Uint64, Uint64) -> [Uint64]
(Uint64, Uint64) -> Uint64 -> Bool
(Uint64, Uint64) -> Uint64 -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
$crange :: (Uint64, Uint64) -> [Uint64]
range :: (Uint64, Uint64) -> [Uint64]
$cindex :: (Uint64, Uint64) -> Uint64 -> Int
index :: (Uint64, Uint64) -> Uint64 -> Int
$cunsafeIndex :: (Uint64, Uint64) -> Uint64 -> Int
unsafeIndex :: (Uint64, Uint64) -> Uint64 -> Int
$cinRange :: (Uint64, Uint64) -> Uint64 -> Bool
inRange :: (Uint64, Uint64) -> Uint64 -> Bool
$crangeSize :: (Uint64, Uint64) -> Int
rangeSize :: (Uint64, Uint64) -> Int
$cunsafeRangeSize :: (Uint64, Uint64) -> Int
unsafeRangeSize :: (Uint64, Uint64) -> Int
BG.Ix
    , Addr# -> Int# -> Uint64
ByteArray# -> Int# -> Uint64
Proxy Uint64 -> Int#
Uint64 -> Int#
(Proxy Uint64 -> Int#)
-> (Uint64 -> Int#)
-> (Proxy Uint64 -> Int#)
-> (Uint64 -> Int#)
-> (ByteArray# -> Int# -> Uint64)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint64 #))
-> (forall s.
    MutableByteArray# s -> Int# -> Uint64 -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s
    -> Int# -> Int# -> Uint64 -> State# s -> State# s)
-> (Addr# -> Int# -> Uint64)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, Uint64 #))
-> (forall s. Addr# -> Int# -> Uint64 -> State# s -> State# s)
-> (forall s.
    Addr# -> Int# -> Int# -> Uint64 -> State# s -> State# s)
-> Prim Uint64
forall s. Addr# -> Int# -> Int# -> Uint64 -> State# s -> State# s
forall s. Addr# -> Int# -> State# s -> (# State# s, Uint64 #)
forall s. Addr# -> Int# -> Uint64 -> State# s -> State# s
forall s.
MutableByteArray# s
-> Int# -> Int# -> Uint64 -> State# s -> State# s
forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint64 #)
forall s.
MutableByteArray# s -> Int# -> Uint64 -> State# s -> State# s
forall a.
(Proxy a -> Int#)
-> (a -> Int#)
-> (Proxy a -> Int#)
-> (a -> Int#)
-> (ByteArray# -> Int# -> a)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, a #))
-> (forall s.
    MutableByteArray# s -> Int# -> a -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s)
-> (Addr# -> Int# -> a)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, a #))
-> (forall s. Addr# -> Int# -> a -> State# s -> State# s)
-> (forall s. Addr# -> Int# -> Int# -> a -> State# s -> State# s)
-> Prim a
$csizeOfType# :: Proxy Uint64 -> Int#
sizeOfType# :: Proxy Uint64 -> Int#
$csizeOf# :: Uint64 -> Int#
sizeOf# :: Uint64 -> Int#
$calignmentOfType# :: Proxy Uint64 -> Int#
alignmentOfType# :: Proxy Uint64 -> Int#
$calignment# :: Uint64 -> Int#
alignment# :: Uint64 -> Int#
$cindexByteArray# :: ByteArray# -> Int# -> Uint64
indexByteArray# :: ByteArray# -> Int# -> Uint64
$creadByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint64 #)
readByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, Uint64 #)
$cwriteByteArray# :: forall s.
MutableByteArray# s -> Int# -> Uint64 -> State# s -> State# s
writeByteArray# :: forall s.
MutableByteArray# s -> Int# -> Uint64 -> State# s -> State# s
$csetByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Uint64 -> State# s -> State# s
setByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> Uint64 -> State# s -> State# s
$cindexOffAddr# :: Addr# -> Int# -> Uint64
indexOffAddr# :: Addr# -> Int# -> Uint64
$creadOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Uint64 #)
readOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, Uint64 #)
$cwriteOffAddr# :: forall s. Addr# -> Int# -> Uint64 -> State# s -> State# s
writeOffAddr# :: forall s. Addr# -> Int# -> Uint64 -> State# s -> State# s
$csetOffAddr# :: forall s. Addr# -> Int# -> Int# -> Uint64 -> State# s -> State# s
setOffAddr# :: forall s. Addr# -> Int# -> Int# -> Uint64 -> State# s -> State# s
BG.Prim
    , Ptr Uint64 -> IO Uint64
Ptr Uint64 -> Int -> IO Uint64
Ptr Uint64 -> Int -> Uint64 -> IO ()
Ptr Uint64 -> Uint64 -> IO ()
Uint64 -> Int
(Uint64 -> Int)
-> (Uint64 -> Int)
-> (Ptr Uint64 -> Int -> IO Uint64)
-> (Ptr Uint64 -> Int -> Uint64 -> IO ())
-> (forall b. Ptr b -> Int -> IO Uint64)
-> (forall b. Ptr b -> Int -> Uint64 -> IO ())
-> (Ptr Uint64 -> IO Uint64)
-> (Ptr Uint64 -> Uint64 -> IO ())
-> Storable Uint64
forall b. Ptr b -> Int -> IO Uint64
forall b. Ptr b -> Int -> Uint64 -> 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
$csizeOf :: Uint64 -> Int
sizeOf :: Uint64 -> Int
$calignment :: Uint64 -> Int
alignment :: Uint64 -> Int
$cpeekElemOff :: Ptr Uint64 -> Int -> IO Uint64
peekElemOff :: Ptr Uint64 -> Int -> IO Uint64
$cpokeElemOff :: Ptr Uint64 -> Int -> Uint64 -> IO ()
pokeElemOff :: Ptr Uint64 -> Int -> Uint64 -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Uint64
peekByteOff :: forall b. Ptr b -> Int -> IO Uint64
$cpokeByteOff :: forall b. Ptr b -> Int -> Uint64 -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> Uint64 -> IO ()
$cpeek :: Ptr Uint64 -> IO Uint64
peek :: Ptr Uint64 -> IO Uint64
$cpoke :: Ptr Uint64 -> Uint64 -> IO ()
poke :: Ptr Uint64 -> Uint64 -> IO ()
BG.Storable
    , Uint64
Uint64 -> Uint64 -> Bounded Uint64
forall a. a -> a -> Bounded a
$cminBound :: Uint64
minBound :: Uint64
$cmaxBound :: Uint64
maxBound :: Uint64
Bounded
    , Int -> Uint64
Uint64 -> Int
Uint64 -> [Uint64]
Uint64 -> Uint64
Uint64 -> Uint64 -> [Uint64]
Uint64 -> Uint64 -> Uint64 -> [Uint64]
(Uint64 -> Uint64)
-> (Uint64 -> Uint64)
-> (Int -> Uint64)
-> (Uint64 -> Int)
-> (Uint64 -> [Uint64])
-> (Uint64 -> Uint64 -> [Uint64])
-> (Uint64 -> Uint64 -> [Uint64])
-> (Uint64 -> Uint64 -> Uint64 -> [Uint64])
-> Enum Uint64
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Uint64 -> Uint64
succ :: Uint64 -> Uint64
$cpred :: Uint64 -> Uint64
pred :: Uint64 -> Uint64
$ctoEnum :: Int -> Uint64
toEnum :: Int -> Uint64
$cfromEnum :: Uint64 -> Int
fromEnum :: Uint64 -> Int
$cenumFrom :: Uint64 -> [Uint64]
enumFrom :: Uint64 -> [Uint64]
$cenumFromThen :: Uint64 -> Uint64 -> [Uint64]
enumFromThen :: Uint64 -> Uint64 -> [Uint64]
$cenumFromTo :: Uint64 -> Uint64 -> [Uint64]
enumFromTo :: Uint64 -> Uint64 -> [Uint64]
$cenumFromThenTo :: Uint64 -> Uint64 -> Uint64 -> [Uint64]
enumFromThenTo :: Uint64 -> Uint64 -> Uint64 -> [Uint64]
Enum
    , Enum Uint64
Real Uint64
(Real Uint64, Enum Uint64) =>
(Uint64 -> Uint64 -> Uint64)
-> (Uint64 -> Uint64 -> Uint64)
-> (Uint64 -> Uint64 -> Uint64)
-> (Uint64 -> Uint64 -> Uint64)
-> (Uint64 -> Uint64 -> (Uint64, Uint64))
-> (Uint64 -> Uint64 -> (Uint64, Uint64))
-> (Uint64 -> Integer)
-> Integral Uint64
Uint64 -> Integer
Uint64 -> Uint64 -> (Uint64, Uint64)
Uint64 -> Uint64 -> Uint64
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
$cquot :: Uint64 -> Uint64 -> Uint64
quot :: Uint64 -> Uint64 -> Uint64
$crem :: Uint64 -> Uint64 -> Uint64
rem :: Uint64 -> Uint64 -> Uint64
$cdiv :: Uint64 -> Uint64 -> Uint64
div :: Uint64 -> Uint64 -> Uint64
$cmod :: Uint64 -> Uint64 -> Uint64
mod :: Uint64 -> Uint64 -> Uint64
$cquotRem :: Uint64 -> Uint64 -> (Uint64, Uint64)
quotRem :: Uint64 -> Uint64 -> (Uint64, Uint64)
$cdivMod :: Uint64 -> Uint64 -> (Uint64, Uint64)
divMod :: Uint64 -> Uint64 -> (Uint64, Uint64)
$ctoInteger :: Uint64 -> Integer
toInteger :: Uint64 -> Integer
Integral
    , Ptr Uint64 -> IO Uint64
(Ptr Uint64 -> IO Uint64) -> ReadRaw Uint64
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr Uint64 -> IO Uint64
readRaw :: Ptr Uint64 -> IO Uint64
Marshal.ReadRaw
    , Proxy Uint64 -> Int
(Proxy Uint64 -> Int) -> (Proxy Uint64 -> Int) -> StaticSize Uint64
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy Uint64 -> Int
staticSizeOf :: Proxy Uint64 -> Int
$cstaticAlignment :: Proxy Uint64 -> Int
staticAlignment :: Proxy Uint64 -> Int
Marshal.StaticSize
    , Ptr Uint64 -> Uint64 -> IO ()
(Ptr Uint64 -> Uint64 -> IO ()) -> WriteRaw Uint64
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr Uint64 -> Uint64 -> IO ()
writeRaw :: Ptr Uint64 -> Uint64 -> IO ()
Marshal.WriteRaw
    , Integer -> Uint64
Uint64 -> Uint64
Uint64 -> Uint64 -> Uint64
(Uint64 -> Uint64 -> Uint64)
-> (Uint64 -> Uint64 -> Uint64)
-> (Uint64 -> Uint64 -> Uint64)
-> (Uint64 -> Uint64)
-> (Uint64 -> Uint64)
-> (Uint64 -> Uint64)
-> (Integer -> Uint64)
-> Num Uint64
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Uint64 -> Uint64 -> Uint64
+ :: Uint64 -> Uint64 -> Uint64
$c- :: Uint64 -> Uint64 -> Uint64
- :: Uint64 -> Uint64 -> Uint64
$c* :: Uint64 -> Uint64 -> Uint64
* :: Uint64 -> Uint64 -> Uint64
$cnegate :: Uint64 -> Uint64
negate :: Uint64 -> Uint64
$cabs :: Uint64 -> Uint64
abs :: Uint64 -> Uint64
$csignum :: Uint64 -> Uint64
signum :: Uint64 -> Uint64
$cfromInteger :: Integer -> Uint64
fromInteger :: Integer -> Uint64
Num
    , Num Uint64
Ord Uint64
(Num Uint64, Ord Uint64) => (Uint64 -> Rational) -> Real Uint64
Uint64 -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Uint64 -> Rational
toRational :: Uint64 -> Rational
Real
    )

instance
  (ty ~ HsBindgen.Runtime.LibC.Word64)
  => BG.CompatHasField.HasField "unwrap" Uint64 ty
  where
  hasField :: Uint64 -> (ty -> Uint64, ty)
hasField =
    \Uint64
x0 ->
      ( \ty
y1 ->
          Uint64{unwrap :: Word64
unwrap = ty
Word64
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" Uint64
x0
      )

instance
  (ty ~ HsBindgen.Runtime.LibC.Word64)
  => BG.HasField "unwrap" (BG.Ptr Uint64) (BG.Ptr ty)
  where
  getField :: Ptr Uint64 -> Ptr ty
getField = Proxy "unwrap" -> Ptr Uint64 -> Ptr (CFieldType Uint64 "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField Uint64 "unwrap" where
  type
    CFieldType Uint64 "unwrap" =
      HsBindgen.Runtime.LibC.Word64

  offset# :: Proxy# Uint64 -> Proxy# "unwrap" -> Int
offset# = \Proxy# Uint64
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | SDL times are signed, 64-bit integers representing nanoseconds since the Unix epoch (Jan 1, 1970).
--
--     They can be converted between POSIX time_t values with SDL_NS_TO_SECONDS() and SDL_SECONDS_TO_NS(), and between Windows FILETIME values with SDL_TimeToWindows() and SDL_TimeFromWindows().
--
--     @since 3.2.0
--
--     [See also]: @SDL_MAX_SINT64@, @SDL_MIN_SINT64@
--
--     [C declaration]: @SDL_Time@, defined at @SDL3\/SDL_stdinc.h 521:16@
newtype SDL_Time = SDL_Time
  { SDL_Time -> Sint64
unwrap :: Sint64
  }
  deriving stock ((forall x. SDL_Time -> Rep SDL_Time x)
-> (forall x. Rep SDL_Time x -> SDL_Time) -> Generic SDL_Time
forall x. Rep SDL_Time x -> SDL_Time
forall x. SDL_Time -> Rep SDL_Time x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_Time -> Rep SDL_Time x
from :: forall x. SDL_Time -> Rep SDL_Time x
$cto :: forall x. Rep SDL_Time x -> SDL_Time
to :: forall x. Rep SDL_Time x -> SDL_Time
BG.Generic, SDL_Time -> SDL_Time -> Bool
(SDL_Time -> SDL_Time -> Bool)
-> (SDL_Time -> SDL_Time -> Bool) -> Eq SDL_Time
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SDL_Time -> SDL_Time -> Bool
== :: SDL_Time -> SDL_Time -> Bool
$c/= :: SDL_Time -> SDL_Time -> Bool
/= :: SDL_Time -> SDL_Time -> Bool
Eq, Eq SDL_Time
Eq SDL_Time =>
(SDL_Time -> SDL_Time -> Ordering)
-> (SDL_Time -> SDL_Time -> Bool)
-> (SDL_Time -> SDL_Time -> Bool)
-> (SDL_Time -> SDL_Time -> Bool)
-> (SDL_Time -> SDL_Time -> Bool)
-> (SDL_Time -> SDL_Time -> SDL_Time)
-> (SDL_Time -> SDL_Time -> SDL_Time)
-> Ord SDL_Time
SDL_Time -> SDL_Time -> Bool
SDL_Time -> SDL_Time -> Ordering
SDL_Time -> SDL_Time -> SDL_Time
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
$ccompare :: SDL_Time -> SDL_Time -> Ordering
compare :: SDL_Time -> SDL_Time -> Ordering
$c< :: SDL_Time -> SDL_Time -> Bool
< :: SDL_Time -> SDL_Time -> Bool
$c<= :: SDL_Time -> SDL_Time -> Bool
<= :: SDL_Time -> SDL_Time -> Bool
$c> :: SDL_Time -> SDL_Time -> Bool
> :: SDL_Time -> SDL_Time -> Bool
$c>= :: SDL_Time -> SDL_Time -> Bool
>= :: SDL_Time -> SDL_Time -> Bool
$cmax :: SDL_Time -> SDL_Time -> SDL_Time
max :: SDL_Time -> SDL_Time -> SDL_Time
$cmin :: SDL_Time -> SDL_Time -> SDL_Time
min :: SDL_Time -> SDL_Time -> SDL_Time
Ord, ReadPrec [SDL_Time]
ReadPrec SDL_Time
Int -> ReadS SDL_Time
ReadS [SDL_Time]
(Int -> ReadS SDL_Time)
-> ReadS [SDL_Time]
-> ReadPrec SDL_Time
-> ReadPrec [SDL_Time]
-> Read SDL_Time
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SDL_Time
readsPrec :: Int -> ReadS SDL_Time
$creadList :: ReadS [SDL_Time]
readList :: ReadS [SDL_Time]
$creadPrec :: ReadPrec SDL_Time
readPrec :: ReadPrec SDL_Time
$creadListPrec :: ReadPrec [SDL_Time]
readListPrec :: ReadPrec [SDL_Time]
Read, Int -> SDL_Time -> ShowS
[SDL_Time] -> ShowS
SDL_Time -> String
(Int -> SDL_Time -> ShowS)
-> (SDL_Time -> String) -> ([SDL_Time] -> ShowS) -> Show SDL_Time
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SDL_Time -> ShowS
showsPrec :: Int -> SDL_Time -> ShowS
$cshow :: SDL_Time -> String
show :: SDL_Time -> String
$cshowList :: [SDL_Time] -> ShowS
showList :: [SDL_Time] -> ShowS
Show)
  deriving newtype
    ( Word64 -> Int -> SDL_Time
SDL_Time -> Int -> Word64
(SDL_Time -> Int -> Word64)
-> (Word64 -> Int -> SDL_Time) -> Bitfield SDL_Time
forall a.
(a -> Int -> Word64) -> (Word64 -> Int -> a) -> Bitfield a
$cnarrow :: SDL_Time -> Int -> Word64
narrow :: SDL_Time -> Int -> Word64
$cextend :: Word64 -> Int -> SDL_Time
extend :: Word64 -> Int -> SDL_Time
BG.Bitfield
    , Eq SDL_Time
SDL_Time
Eq SDL_Time =>
(SDL_Time -> SDL_Time -> SDL_Time)
-> (SDL_Time -> SDL_Time -> SDL_Time)
-> (SDL_Time -> SDL_Time -> SDL_Time)
-> (SDL_Time -> SDL_Time)
-> (SDL_Time -> Int -> SDL_Time)
-> (SDL_Time -> Int -> SDL_Time)
-> SDL_Time
-> (Int -> SDL_Time)
-> (SDL_Time -> Int -> SDL_Time)
-> (SDL_Time -> Int -> SDL_Time)
-> (SDL_Time -> Int -> SDL_Time)
-> (SDL_Time -> Int -> Bool)
-> (SDL_Time -> Maybe Int)
-> (SDL_Time -> Int)
-> (SDL_Time -> Bool)
-> (SDL_Time -> Int -> SDL_Time)
-> (SDL_Time -> Int -> SDL_Time)
-> (SDL_Time -> Int -> SDL_Time)
-> (SDL_Time -> Int -> SDL_Time)
-> (SDL_Time -> Int -> SDL_Time)
-> (SDL_Time -> Int -> SDL_Time)
-> (SDL_Time -> Int)
-> Bits SDL_Time
Int -> SDL_Time
SDL_Time -> Bool
SDL_Time -> Int
SDL_Time -> Maybe Int
SDL_Time -> SDL_Time
SDL_Time -> Int -> Bool
SDL_Time -> Int -> SDL_Time
SDL_Time -> SDL_Time -> SDL_Time
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
$c.&. :: SDL_Time -> SDL_Time -> SDL_Time
.&. :: SDL_Time -> SDL_Time -> SDL_Time
$c.|. :: SDL_Time -> SDL_Time -> SDL_Time
.|. :: SDL_Time -> SDL_Time -> SDL_Time
$cxor :: SDL_Time -> SDL_Time -> SDL_Time
xor :: SDL_Time -> SDL_Time -> SDL_Time
$ccomplement :: SDL_Time -> SDL_Time
complement :: SDL_Time -> SDL_Time
$cshift :: SDL_Time -> Int -> SDL_Time
shift :: SDL_Time -> Int -> SDL_Time
$crotate :: SDL_Time -> Int -> SDL_Time
rotate :: SDL_Time -> Int -> SDL_Time
$czeroBits :: SDL_Time
zeroBits :: SDL_Time
$cbit :: Int -> SDL_Time
bit :: Int -> SDL_Time
$csetBit :: SDL_Time -> Int -> SDL_Time
setBit :: SDL_Time -> Int -> SDL_Time
$cclearBit :: SDL_Time -> Int -> SDL_Time
clearBit :: SDL_Time -> Int -> SDL_Time
$ccomplementBit :: SDL_Time -> Int -> SDL_Time
complementBit :: SDL_Time -> Int -> SDL_Time
$ctestBit :: SDL_Time -> Int -> Bool
testBit :: SDL_Time -> Int -> Bool
$cbitSizeMaybe :: SDL_Time -> Maybe Int
bitSizeMaybe :: SDL_Time -> Maybe Int
$cbitSize :: SDL_Time -> Int
bitSize :: SDL_Time -> Int
$cisSigned :: SDL_Time -> Bool
isSigned :: SDL_Time -> Bool
$cshiftL :: SDL_Time -> Int -> SDL_Time
shiftL :: SDL_Time -> Int -> SDL_Time
$cunsafeShiftL :: SDL_Time -> Int -> SDL_Time
unsafeShiftL :: SDL_Time -> Int -> SDL_Time
$cshiftR :: SDL_Time -> Int -> SDL_Time
shiftR :: SDL_Time -> Int -> SDL_Time
$cunsafeShiftR :: SDL_Time -> Int -> SDL_Time
unsafeShiftR :: SDL_Time -> Int -> SDL_Time
$crotateL :: SDL_Time -> Int -> SDL_Time
rotateL :: SDL_Time -> Int -> SDL_Time
$crotateR :: SDL_Time -> Int -> SDL_Time
rotateR :: SDL_Time -> Int -> SDL_Time
$cpopCount :: SDL_Time -> Int
popCount :: SDL_Time -> Int
BG.Bits
    , Bits SDL_Time
Bits SDL_Time =>
(SDL_Time -> Int)
-> (SDL_Time -> Int) -> (SDL_Time -> Int) -> FiniteBits SDL_Time
SDL_Time -> Int
forall b.
Bits b =>
(b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
$cfiniteBitSize :: SDL_Time -> Int
finiteBitSize :: SDL_Time -> Int
$ccountLeadingZeros :: SDL_Time -> Int
countLeadingZeros :: SDL_Time -> Int
$ccountTrailingZeros :: SDL_Time -> Int
countTrailingZeros :: SDL_Time -> Int
BG.FiniteBits
    , FFIType SDL_Time -> SDL_Time
SDL_Time -> FFIType SDL_Time
(SDL_Time -> FFIType SDL_Time)
-> (FFIType SDL_Time -> SDL_Time) -> HasFFIType SDL_Time
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: SDL_Time -> FFIType SDL_Time
toFFIType :: SDL_Time -> FFIType SDL_Time
$cfromFFIType :: FFIType SDL_Time -> SDL_Time
fromFFIType :: FFIType SDL_Time -> SDL_Time
BG.HasFFIType
    , Ord SDL_Time
Ord SDL_Time =>
((SDL_Time, SDL_Time) -> [SDL_Time])
-> ((SDL_Time, SDL_Time) -> SDL_Time -> Int)
-> ((SDL_Time, SDL_Time) -> SDL_Time -> Int)
-> ((SDL_Time, SDL_Time) -> SDL_Time -> Bool)
-> ((SDL_Time, SDL_Time) -> Int)
-> ((SDL_Time, SDL_Time) -> Int)
-> Ix SDL_Time
(SDL_Time, SDL_Time) -> Int
(SDL_Time, SDL_Time) -> [SDL_Time]
(SDL_Time, SDL_Time) -> SDL_Time -> Bool
(SDL_Time, SDL_Time) -> SDL_Time -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
$crange :: (SDL_Time, SDL_Time) -> [SDL_Time]
range :: (SDL_Time, SDL_Time) -> [SDL_Time]
$cindex :: (SDL_Time, SDL_Time) -> SDL_Time -> Int
index :: (SDL_Time, SDL_Time) -> SDL_Time -> Int
$cunsafeIndex :: (SDL_Time, SDL_Time) -> SDL_Time -> Int
unsafeIndex :: (SDL_Time, SDL_Time) -> SDL_Time -> Int
$cinRange :: (SDL_Time, SDL_Time) -> SDL_Time -> Bool
inRange :: (SDL_Time, SDL_Time) -> SDL_Time -> Bool
$crangeSize :: (SDL_Time, SDL_Time) -> Int
rangeSize :: (SDL_Time, SDL_Time) -> Int
$cunsafeRangeSize :: (SDL_Time, SDL_Time) -> Int
unsafeRangeSize :: (SDL_Time, SDL_Time) -> Int
BG.Ix
    , Addr# -> Int# -> SDL_Time
ByteArray# -> Int# -> SDL_Time
Proxy SDL_Time -> Int#
SDL_Time -> Int#
(Proxy SDL_Time -> Int#)
-> (SDL_Time -> Int#)
-> (Proxy SDL_Time -> Int#)
-> (SDL_Time -> Int#)
-> (ByteArray# -> Int# -> SDL_Time)
-> (forall s.
    MutableByteArray# s
    -> Int# -> State# s -> (# State# s, SDL_Time #))
-> (forall s.
    MutableByteArray# s -> Int# -> SDL_Time -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s
    -> Int# -> Int# -> SDL_Time -> State# s -> State# s)
-> (Addr# -> Int# -> SDL_Time)
-> (forall s.
    Addr# -> Int# -> State# s -> (# State# s, SDL_Time #))
-> (forall s. Addr# -> Int# -> SDL_Time -> State# s -> State# s)
-> (forall s.
    Addr# -> Int# -> Int# -> SDL_Time -> State# s -> State# s)
-> Prim SDL_Time
forall s. Addr# -> Int# -> Int# -> SDL_Time -> State# s -> State# s
forall s. Addr# -> Int# -> State# s -> (# State# s, SDL_Time #)
forall s. Addr# -> Int# -> SDL_Time -> State# s -> State# s
forall s.
MutableByteArray# s
-> Int# -> Int# -> SDL_Time -> State# s -> State# s
forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, SDL_Time #)
forall s.
MutableByteArray# s -> Int# -> SDL_Time -> State# s -> State# s
forall a.
(Proxy a -> Int#)
-> (a -> Int#)
-> (Proxy a -> Int#)
-> (a -> Int#)
-> (ByteArray# -> Int# -> a)
-> (forall s.
    MutableByteArray# s -> Int# -> State# s -> (# State# s, a #))
-> (forall s.
    MutableByteArray# s -> Int# -> a -> State# s -> State# s)
-> (forall s.
    MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s)
-> (Addr# -> Int# -> a)
-> (forall s. Addr# -> Int# -> State# s -> (# State# s, a #))
-> (forall s. Addr# -> Int# -> a -> State# s -> State# s)
-> (forall s. Addr# -> Int# -> Int# -> a -> State# s -> State# s)
-> Prim a
$csizeOfType# :: Proxy SDL_Time -> Int#
sizeOfType# :: Proxy SDL_Time -> Int#
$csizeOf# :: SDL_Time -> Int#
sizeOf# :: SDL_Time -> Int#
$calignmentOfType# :: Proxy SDL_Time -> Int#
alignmentOfType# :: Proxy SDL_Time -> Int#
$calignment# :: SDL_Time -> Int#
alignment# :: SDL_Time -> Int#
$cindexByteArray# :: ByteArray# -> Int# -> SDL_Time
indexByteArray# :: ByteArray# -> Int# -> SDL_Time
$creadByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, SDL_Time #)
readByteArray# :: forall s.
MutableByteArray# s -> Int# -> State# s -> (# State# s, SDL_Time #)
$cwriteByteArray# :: forall s.
MutableByteArray# s -> Int# -> SDL_Time -> State# s -> State# s
writeByteArray# :: forall s.
MutableByteArray# s -> Int# -> SDL_Time -> State# s -> State# s
$csetByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> SDL_Time -> State# s -> State# s
setByteArray# :: forall s.
MutableByteArray# s
-> Int# -> Int# -> SDL_Time -> State# s -> State# s
$cindexOffAddr# :: Addr# -> Int# -> SDL_Time
indexOffAddr# :: Addr# -> Int# -> SDL_Time
$creadOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, SDL_Time #)
readOffAddr# :: forall s. Addr# -> Int# -> State# s -> (# State# s, SDL_Time #)
$cwriteOffAddr# :: forall s. Addr# -> Int# -> SDL_Time -> State# s -> State# s
writeOffAddr# :: forall s. Addr# -> Int# -> SDL_Time -> State# s -> State# s
$csetOffAddr# :: forall s. Addr# -> Int# -> Int# -> SDL_Time -> State# s -> State# s
setOffAddr# :: forall s. Addr# -> Int# -> Int# -> SDL_Time -> State# s -> State# s
BG.Prim
    , Ptr SDL_Time -> IO SDL_Time
Ptr SDL_Time -> Int -> IO SDL_Time
Ptr SDL_Time -> Int -> SDL_Time -> IO ()
Ptr SDL_Time -> SDL_Time -> IO ()
SDL_Time -> Int
(SDL_Time -> Int)
-> (SDL_Time -> Int)
-> (Ptr SDL_Time -> Int -> IO SDL_Time)
-> (Ptr SDL_Time -> Int -> SDL_Time -> IO ())
-> (forall b. Ptr b -> Int -> IO SDL_Time)
-> (forall b. Ptr b -> Int -> SDL_Time -> IO ())
-> (Ptr SDL_Time -> IO SDL_Time)
-> (Ptr SDL_Time -> SDL_Time -> IO ())
-> Storable SDL_Time
forall b. Ptr b -> Int -> IO SDL_Time
forall b. Ptr b -> Int -> SDL_Time -> 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
$csizeOf :: SDL_Time -> Int
sizeOf :: SDL_Time -> Int
$calignment :: SDL_Time -> Int
alignment :: SDL_Time -> Int
$cpeekElemOff :: Ptr SDL_Time -> Int -> IO SDL_Time
peekElemOff :: Ptr SDL_Time -> Int -> IO SDL_Time
$cpokeElemOff :: Ptr SDL_Time -> Int -> SDL_Time -> IO ()
pokeElemOff :: Ptr SDL_Time -> Int -> SDL_Time -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO SDL_Time
peekByteOff :: forall b. Ptr b -> Int -> IO SDL_Time
$cpokeByteOff :: forall b. Ptr b -> Int -> SDL_Time -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> SDL_Time -> IO ()
$cpeek :: Ptr SDL_Time -> IO SDL_Time
peek :: Ptr SDL_Time -> IO SDL_Time
$cpoke :: Ptr SDL_Time -> SDL_Time -> IO ()
poke :: Ptr SDL_Time -> SDL_Time -> IO ()
BG.Storable
    , SDL_Time
SDL_Time -> SDL_Time -> Bounded SDL_Time
forall a. a -> a -> Bounded a
$cminBound :: SDL_Time
minBound :: SDL_Time
$cmaxBound :: SDL_Time
maxBound :: SDL_Time
Bounded
    , Int -> SDL_Time
SDL_Time -> Int
SDL_Time -> [SDL_Time]
SDL_Time -> SDL_Time
SDL_Time -> SDL_Time -> [SDL_Time]
SDL_Time -> SDL_Time -> SDL_Time -> [SDL_Time]
(SDL_Time -> SDL_Time)
-> (SDL_Time -> SDL_Time)
-> (Int -> SDL_Time)
-> (SDL_Time -> Int)
-> (SDL_Time -> [SDL_Time])
-> (SDL_Time -> SDL_Time -> [SDL_Time])
-> (SDL_Time -> SDL_Time -> [SDL_Time])
-> (SDL_Time -> SDL_Time -> SDL_Time -> [SDL_Time])
-> Enum SDL_Time
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: SDL_Time -> SDL_Time
succ :: SDL_Time -> SDL_Time
$cpred :: SDL_Time -> SDL_Time
pred :: SDL_Time -> SDL_Time
$ctoEnum :: Int -> SDL_Time
toEnum :: Int -> SDL_Time
$cfromEnum :: SDL_Time -> Int
fromEnum :: SDL_Time -> Int
$cenumFrom :: SDL_Time -> [SDL_Time]
enumFrom :: SDL_Time -> [SDL_Time]
$cenumFromThen :: SDL_Time -> SDL_Time -> [SDL_Time]
enumFromThen :: SDL_Time -> SDL_Time -> [SDL_Time]
$cenumFromTo :: SDL_Time -> SDL_Time -> [SDL_Time]
enumFromTo :: SDL_Time -> SDL_Time -> [SDL_Time]
$cenumFromThenTo :: SDL_Time -> SDL_Time -> SDL_Time -> [SDL_Time]
enumFromThenTo :: SDL_Time -> SDL_Time -> SDL_Time -> [SDL_Time]
Enum
    , Enum SDL_Time
Real SDL_Time
(Real SDL_Time, Enum SDL_Time) =>
(SDL_Time -> SDL_Time -> SDL_Time)
-> (SDL_Time -> SDL_Time -> SDL_Time)
-> (SDL_Time -> SDL_Time -> SDL_Time)
-> (SDL_Time -> SDL_Time -> SDL_Time)
-> (SDL_Time -> SDL_Time -> (SDL_Time, SDL_Time))
-> (SDL_Time -> SDL_Time -> (SDL_Time, SDL_Time))
-> (SDL_Time -> Integer)
-> Integral SDL_Time
SDL_Time -> Integer
SDL_Time -> SDL_Time -> (SDL_Time, SDL_Time)
SDL_Time -> SDL_Time -> SDL_Time
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
$cquot :: SDL_Time -> SDL_Time -> SDL_Time
quot :: SDL_Time -> SDL_Time -> SDL_Time
$crem :: SDL_Time -> SDL_Time -> SDL_Time
rem :: SDL_Time -> SDL_Time -> SDL_Time
$cdiv :: SDL_Time -> SDL_Time -> SDL_Time
div :: SDL_Time -> SDL_Time -> SDL_Time
$cmod :: SDL_Time -> SDL_Time -> SDL_Time
mod :: SDL_Time -> SDL_Time -> SDL_Time
$cquotRem :: SDL_Time -> SDL_Time -> (SDL_Time, SDL_Time)
quotRem :: SDL_Time -> SDL_Time -> (SDL_Time, SDL_Time)
$cdivMod :: SDL_Time -> SDL_Time -> (SDL_Time, SDL_Time)
divMod :: SDL_Time -> SDL_Time -> (SDL_Time, SDL_Time)
$ctoInteger :: SDL_Time -> Integer
toInteger :: SDL_Time -> Integer
Integral
    , Ptr SDL_Time -> IO SDL_Time
(Ptr SDL_Time -> IO SDL_Time) -> ReadRaw SDL_Time
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr SDL_Time -> IO SDL_Time
readRaw :: Ptr SDL_Time -> IO SDL_Time
Marshal.ReadRaw
    , Proxy SDL_Time -> Int
(Proxy SDL_Time -> Int)
-> (Proxy SDL_Time -> Int) -> StaticSize SDL_Time
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy SDL_Time -> Int
staticSizeOf :: Proxy SDL_Time -> Int
$cstaticAlignment :: Proxy SDL_Time -> Int
staticAlignment :: Proxy SDL_Time -> Int
Marshal.StaticSize
    , Ptr SDL_Time -> SDL_Time -> IO ()
(Ptr SDL_Time -> SDL_Time -> IO ()) -> WriteRaw SDL_Time
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr SDL_Time -> SDL_Time -> IO ()
writeRaw :: Ptr SDL_Time -> SDL_Time -> IO ()
Marshal.WriteRaw
    , Integer -> SDL_Time
SDL_Time -> SDL_Time
SDL_Time -> SDL_Time -> SDL_Time
(SDL_Time -> SDL_Time -> SDL_Time)
-> (SDL_Time -> SDL_Time -> SDL_Time)
-> (SDL_Time -> SDL_Time -> SDL_Time)
-> (SDL_Time -> SDL_Time)
-> (SDL_Time -> SDL_Time)
-> (SDL_Time -> SDL_Time)
-> (Integer -> SDL_Time)
-> Num SDL_Time
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: SDL_Time -> SDL_Time -> SDL_Time
+ :: SDL_Time -> SDL_Time -> SDL_Time
$c- :: SDL_Time -> SDL_Time -> SDL_Time
- :: SDL_Time -> SDL_Time -> SDL_Time
$c* :: SDL_Time -> SDL_Time -> SDL_Time
* :: SDL_Time -> SDL_Time -> SDL_Time
$cnegate :: SDL_Time -> SDL_Time
negate :: SDL_Time -> SDL_Time
$cabs :: SDL_Time -> SDL_Time
abs :: SDL_Time -> SDL_Time
$csignum :: SDL_Time -> SDL_Time
signum :: SDL_Time -> SDL_Time
$cfromInteger :: Integer -> SDL_Time
fromInteger :: Integer -> SDL_Time
Num
    , Num SDL_Time
Ord SDL_Time
(Num SDL_Time, Ord SDL_Time) =>
(SDL_Time -> Rational) -> Real SDL_Time
SDL_Time -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: SDL_Time -> Rational
toRational :: SDL_Time -> Rational
Real
    )

instance (ty ~ Sint64) => BG.CompatHasField.HasField "unwrap" SDL_Time ty where
  hasField :: SDL_Time -> (ty -> SDL_Time, ty)
hasField =
    \SDL_Time
x0 ->
      ( \ty
y1 ->
          SDL_Time{unwrap :: Sint64
unwrap = ty
Sint64
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_Time
x0
      )

instance
  (ty ~ Sint64)
  => BG.HasField "unwrap" (BG.Ptr SDL_Time) (BG.Ptr ty)
  where
  getField :: Ptr SDL_Time -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_Time -> Ptr (CFieldType SDL_Time "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_Time "unwrap" where
  type CFieldType SDL_Time "unwrap" = Sint64

  offset# :: Proxy# SDL_Time -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_Time
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | Epsilon constant, used for comparing floating-point numbers.
--
--     Equals by default to platform-defined @FLT_EPSILON@, or @1.1920928955078125e-07F@ if that\'s not available.
--
--     @since 3.2.0
--
--     [C declaration]: @macro SDL_FLT_EPSILON@, defined at @SDL3\/SDL_stdinc.h 544:9@
sDL_FLT_EPSILON :: BG.CFloat
sDL_FLT_EPSILON :: CFloat
sDL_FLT_EPSILON = (CFloat
1.1920929e-7 :: BG.CFloat)

-- | [C declaration]: @macro SDL_PRILL_PREFIX@, literal @\"ll\"@, defined at @SDL3\/SDL_stdinc.h 808:9@
sDL_PRILL_PREFIX :: BG.ByteString
sDL_PRILL_PREFIX :: ByteString
sDL_PRILL_PREFIX = [Word8] -> ByteString
BG.pack [Word8
0x6C, Word8
0x6C]

-- | [C declaration]: @struct SDL_alignment_test@, defined at @SDL3\/SDL_stdinc.h 1182:16@
data SDL_alignment_test = SDL_alignment_test
  { SDL_alignment_test -> Uint8
a :: Uint8
  -- ^ [C declaration]: @a@, defined at @SDL3\/SDL_stdinc.h 1184:11@
  , SDL_alignment_test -> Ptr Void
b :: BG.Ptr BG.Void
  -- ^ [C declaration]: @b@, defined at @SDL3\/SDL_stdinc.h 1185:11@
  }
  deriving stock ((forall x. SDL_alignment_test -> Rep SDL_alignment_test x)
-> (forall x. Rep SDL_alignment_test x -> SDL_alignment_test)
-> Generic SDL_alignment_test
forall x. Rep SDL_alignment_test x -> SDL_alignment_test
forall x. SDL_alignment_test -> Rep SDL_alignment_test x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_alignment_test -> Rep SDL_alignment_test x
from :: forall x. SDL_alignment_test -> Rep SDL_alignment_test x
$cto :: forall x. Rep SDL_alignment_test x -> SDL_alignment_test
to :: forall x. Rep SDL_alignment_test x -> SDL_alignment_test
BG.Generic, SDL_alignment_test -> SDL_alignment_test -> Bool
(SDL_alignment_test -> SDL_alignment_test -> Bool)
-> (SDL_alignment_test -> SDL_alignment_test -> Bool)
-> Eq SDL_alignment_test
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SDL_alignment_test -> SDL_alignment_test -> Bool
== :: SDL_alignment_test -> SDL_alignment_test -> Bool
$c/= :: SDL_alignment_test -> SDL_alignment_test -> Bool
/= :: SDL_alignment_test -> SDL_alignment_test -> Bool
Eq, Int -> SDL_alignment_test -> ShowS
[SDL_alignment_test] -> ShowS
SDL_alignment_test -> String
(Int -> SDL_alignment_test -> ShowS)
-> (SDL_alignment_test -> String)
-> ([SDL_alignment_test] -> ShowS)
-> Show SDL_alignment_test
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SDL_alignment_test -> ShowS
showsPrec :: Int -> SDL_alignment_test -> ShowS
$cshow :: SDL_alignment_test -> String
show :: SDL_alignment_test -> String
$cshowList :: [SDL_alignment_test] -> ShowS
showList :: [SDL_alignment_test] -> ShowS
Show)

instance Marshal.StaticSize SDL_alignment_test where
  staticSizeOf :: Proxy SDL_alignment_test -> Int
staticSizeOf = \Proxy SDL_alignment_test
_ -> (Int
16 :: Int)

  staticAlignment :: Proxy SDL_alignment_test -> Int
staticAlignment = \Proxy SDL_alignment_test
_ -> (Int
8 :: Int)

instance Marshal.ReadRaw SDL_alignment_test where
  readRaw :: Ptr SDL_alignment_test -> IO SDL_alignment_test
readRaw =
    \Ptr SDL_alignment_test
ptr0 ->
      (Uint8 -> Ptr Void -> SDL_alignment_test)
-> IO (Uint8 -> Ptr Void -> SDL_alignment_test)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Uint8 -> Ptr Void -> SDL_alignment_test
SDL_alignment_test
        IO (Uint8 -> Ptr Void -> SDL_alignment_test)
-> IO Uint8 -> IO (Ptr Void -> SDL_alignment_test)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Proxy "a"
-> Ptr SDL_alignment_test -> IO (CFieldType SDL_alignment_test "a")
forall a (field :: Symbol).
(HasCField a field, ReadRaw (CFieldType a field)) =>
Proxy field -> Ptr a -> IO (CFieldType a field)
HasCField.readRaw (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"a") Ptr SDL_alignment_test
ptr0
        IO (Ptr Void -> SDL_alignment_test)
-> IO (Ptr Void) -> IO SDL_alignment_test
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Proxy "b"
-> Ptr SDL_alignment_test -> IO (CFieldType SDL_alignment_test "b")
forall a (field :: Symbol).
(HasCField a field, ReadRaw (CFieldType a field)) =>
Proxy field -> Ptr a -> IO (CFieldType a field)
HasCField.readRaw (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"b") Ptr SDL_alignment_test
ptr0

instance Marshal.WriteRaw SDL_alignment_test where
  writeRaw :: Ptr SDL_alignment_test -> SDL_alignment_test -> IO ()
writeRaw =
    \Ptr SDL_alignment_test
ptr0 ->
      \SDL_alignment_test
s1 ->
        case SDL_alignment_test
s1 of
          SDL_alignment_test Uint8
a2 Ptr Void
b3 ->
            Proxy "a"
-> Ptr SDL_alignment_test
-> CFieldType SDL_alignment_test "a"
-> IO ()
forall a (field :: Symbol).
(HasCField a field, WriteRaw (CFieldType a field)) =>
Proxy field -> Ptr a -> CFieldType a field -> IO ()
HasCField.writeRaw (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"a") Ptr SDL_alignment_test
ptr0 CFieldType SDL_alignment_test "a"
Uint8
a2
              IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Proxy "b"
-> Ptr SDL_alignment_test
-> CFieldType SDL_alignment_test "b"
-> IO ()
forall a (field :: Symbol).
(HasCField a field, WriteRaw (CFieldType a field)) =>
Proxy field -> Ptr a -> CFieldType a field -> IO ()
HasCField.writeRaw (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"b") Ptr SDL_alignment_test
ptr0 Ptr Void
CFieldType SDL_alignment_test "b"
b3

deriving via Marshal.EquivStorable SDL_alignment_test instance BG.Storable SDL_alignment_test

deriving via
  Struct.IsStructViaReadRaw SDL_alignment_test
  instance
    Struct.IsStruct SDL_alignment_test

-- | [C declaration]: @a@, defined at @SDL3\/SDL_stdinc.h 1184:11@
instance
  (ty ~ Uint8)
  => BG.CompatHasField.HasField "a" SDL_alignment_test ty
  where
  hasField :: SDL_alignment_test -> (ty -> SDL_alignment_test, ty)
hasField =
    \SDL_alignment_test
x0 ->
      ( \ty
y1 ->
          SDL_alignment_test{a :: Uint8
a = ty
Uint8
y1, b :: Ptr Void
b = forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"b" SDL_alignment_test
x0}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"a" SDL_alignment_test
x0
      )

instance
  (ty ~ Uint8)
  => BG.HasField "a" (BG.Ptr SDL_alignment_test) (BG.Ptr ty)
  where
  getField :: Ptr SDL_alignment_test -> Ptr ty
getField = Proxy "a"
-> Ptr SDL_alignment_test
-> Ptr (CFieldType SDL_alignment_test "a")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"a")

instance HasCField.HasCField SDL_alignment_test "a" where
  type CFieldType SDL_alignment_test "a" = Uint8

  offset# :: Proxy# SDL_alignment_test -> Proxy# "a" -> Int
offset# = \Proxy# SDL_alignment_test
_ -> \Proxy# "a"
_ -> Int
0

-- | [C declaration]: @b@, defined at @SDL3\/SDL_stdinc.h 1185:11@
instance
  (ty ~ BG.Ptr BG.Void)
  => BG.CompatHasField.HasField "b" SDL_alignment_test ty
  where
  hasField :: SDL_alignment_test -> (ty -> SDL_alignment_test, ty)
hasField =
    \SDL_alignment_test
x0 ->
      ( \ty
y1 ->
          SDL_alignment_test{b :: Ptr Void
b = ty
Ptr Void
y1, a :: Uint8
a = forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"a" SDL_alignment_test
x0}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"b" SDL_alignment_test
x0
      )

instance
  (ty ~ BG.Ptr BG.Void)
  => BG.HasField "b" (BG.Ptr SDL_alignment_test) (BG.Ptr ty)
  where
  getField :: Ptr SDL_alignment_test -> Ptr ty
getField = Proxy "b"
-> Ptr SDL_alignment_test
-> Ptr (CFieldType SDL_alignment_test "b")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"b")

instance HasCField.HasCField SDL_alignment_test "b" where
  type
    CFieldType SDL_alignment_test "b" =
      BG.Ptr BG.Void

  offset# :: Proxy# SDL_alignment_test -> Proxy# "b" -> Int
offset# = \Proxy# SDL_alignment_test
_ -> \Proxy# "b"
_ -> Int
8

-- | [C declaration]: @enum SDL_DUMMY_ENUM@, defined at @SDL3\/SDL_stdinc.h 1202:14@
newtype SDL_DUMMY_ENUM = SDL_DUMMY_ENUM
  { SDL_DUMMY_ENUM -> CUInt
unwrap :: BG.CUInt
  }
  deriving stock ((forall x. SDL_DUMMY_ENUM -> Rep SDL_DUMMY_ENUM x)
-> (forall x. Rep SDL_DUMMY_ENUM x -> SDL_DUMMY_ENUM)
-> Generic SDL_DUMMY_ENUM
forall x. Rep SDL_DUMMY_ENUM x -> SDL_DUMMY_ENUM
forall x. SDL_DUMMY_ENUM -> Rep SDL_DUMMY_ENUM x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_DUMMY_ENUM -> Rep SDL_DUMMY_ENUM x
from :: forall x. SDL_DUMMY_ENUM -> Rep SDL_DUMMY_ENUM x
$cto :: forall x. Rep SDL_DUMMY_ENUM x -> SDL_DUMMY_ENUM
to :: forall x. Rep SDL_DUMMY_ENUM x -> SDL_DUMMY_ENUM
BG.Generic, SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool
(SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool)
-> (SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool) -> Eq SDL_DUMMY_ENUM
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool
== :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool
$c/= :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool
/= :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool
Eq, Eq SDL_DUMMY_ENUM
Eq SDL_DUMMY_ENUM =>
(SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Ordering)
-> (SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool)
-> (SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool)
-> (SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool)
-> (SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool)
-> (SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM)
-> (SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM)
-> Ord SDL_DUMMY_ENUM
SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool
SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Ordering
SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM
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
$ccompare :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Ordering
compare :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Ordering
$c< :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool
< :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool
$c<= :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool
<= :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool
$c> :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool
> :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool
$c>= :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool
>= :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> Bool
$cmax :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM
max :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM
$cmin :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM
min :: SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM
Ord)
  deriving newtype (FFIType SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM
SDL_DUMMY_ENUM -> FFIType SDL_DUMMY_ENUM
(SDL_DUMMY_ENUM -> FFIType SDL_DUMMY_ENUM)
-> (FFIType SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM)
-> HasFFIType SDL_DUMMY_ENUM
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: SDL_DUMMY_ENUM -> FFIType SDL_DUMMY_ENUM
toFFIType :: SDL_DUMMY_ENUM -> FFIType SDL_DUMMY_ENUM
$cfromFFIType :: FFIType SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM
fromFFIType :: FFIType SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM
BG.HasFFIType)

instance Marshal.StaticSize SDL_DUMMY_ENUM where
  staticSizeOf :: Proxy SDL_DUMMY_ENUM -> Int
staticSizeOf = \Proxy SDL_DUMMY_ENUM
_ -> (Int
4 :: Int)

  staticAlignment :: Proxy SDL_DUMMY_ENUM -> Int
staticAlignment = \Proxy SDL_DUMMY_ENUM
_ -> (Int
4 :: Int)

instance Marshal.ReadRaw SDL_DUMMY_ENUM where
  readRaw :: Ptr SDL_DUMMY_ENUM -> IO SDL_DUMMY_ENUM
readRaw =
    \Ptr SDL_DUMMY_ENUM
ptr0 ->
      (CUInt -> SDL_DUMMY_ENUM) -> IO (CUInt -> SDL_DUMMY_ENUM)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure CUInt -> SDL_DUMMY_ENUM
SDL_DUMMY_ENUM
        IO (CUInt -> SDL_DUMMY_ENUM) -> IO CUInt -> IO SDL_DUMMY_ENUM
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr SDL_DUMMY_ENUM -> Int -> IO CUInt
forall a b. ReadRaw a => Ptr b -> Int -> IO a
Marshal.readRawByteOff Ptr SDL_DUMMY_ENUM
ptr0 (Int
0 :: Int)

instance Marshal.WriteRaw SDL_DUMMY_ENUM where
  writeRaw :: Ptr SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM -> IO ()
writeRaw =
    \Ptr SDL_DUMMY_ENUM
ptr0 ->
      \SDL_DUMMY_ENUM
s1 ->
        case SDL_DUMMY_ENUM
s1 of
          SDL_DUMMY_ENUM CUInt
unwrap2 ->
            Ptr SDL_DUMMY_ENUM -> Int -> CUInt -> IO ()
forall a b. WriteRaw a => Ptr b -> Int -> a -> IO ()
Marshal.writeRawByteOff Ptr SDL_DUMMY_ENUM
ptr0 (Int
0 :: Int) CUInt
unwrap2

deriving via Marshal.EquivStorable SDL_DUMMY_ENUM instance BG.Storable SDL_DUMMY_ENUM

deriving via BG.CUInt instance BG.Prim SDL_DUMMY_ENUM

instance CEnum.CEnum SDL_DUMMY_ENUM where
  type CEnumZ SDL_DUMMY_ENUM = BG.CUInt

  toCEnum :: CEnumZ SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM
toCEnum = CUInt -> SDL_DUMMY_ENUM
CEnumZ SDL_DUMMY_ENUM -> SDL_DUMMY_ENUM
SDL_DUMMY_ENUM

  fromCEnum :: SDL_DUMMY_ENUM -> CEnumZ SDL_DUMMY_ENUM
fromCEnum = forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap"

  declaredValues :: forall (proxy :: * -> *).
proxy SDL_DUMMY_ENUM -> DeclaredValues SDL_DUMMY_ENUM
declaredValues =
    \proxy SDL_DUMMY_ENUM
_ ->
      [(CEnumZ SDL_DUMMY_ENUM, NonEmpty String)]
-> DeclaredValues SDL_DUMMY_ENUM
forall a.
Ord (CEnumZ a) =>
[(CEnumZ a, NonEmpty String)] -> DeclaredValues a
CEnum.declaredValuesFromList [(CUInt
CEnumZ SDL_DUMMY_ENUM
0, String -> NonEmpty String
forall a. a -> NonEmpty a
BG.singleton String
"DUMMY_ENUM_VALUE")]

  showsUndeclared :: forall (proxy :: * -> *).
proxy SDL_DUMMY_ENUM -> Int -> CEnumZ SDL_DUMMY_ENUM -> ShowS
showsUndeclared =
    String
-> proxy SDL_DUMMY_ENUM -> Int -> CEnumZ SDL_DUMMY_ENUM -> ShowS
forall a (proxy :: * -> *).
Show (CEnumZ a) =>
String -> proxy a -> Int -> CEnumZ a -> ShowS
CEnum.showsWrappedUndeclared String
"SDL_DUMMY_ENUM"

  readPrecUndeclared :: ReadPrec SDL_DUMMY_ENUM
readPrecUndeclared =
    String -> ReadPrec SDL_DUMMY_ENUM
forall a. (CEnum a, Read (CEnumZ a)) => String -> ReadPrec a
CEnum.readPrecWrappedUndeclared String
"SDL_DUMMY_ENUM"

  isDeclared :: SDL_DUMMY_ENUM -> Bool
isDeclared = SDL_DUMMY_ENUM -> Bool
forall a. SequentialCEnum a => a -> Bool
CEnum.seqIsDeclared

  mkDeclared :: CEnumZ SDL_DUMMY_ENUM -> Maybe SDL_DUMMY_ENUM
mkDeclared = CEnumZ SDL_DUMMY_ENUM -> Maybe SDL_DUMMY_ENUM
forall a. SequentialCEnum a => CEnumZ a -> Maybe a
CEnum.seqMkDeclared

instance CEnum.SequentialCEnum SDL_DUMMY_ENUM where
  minDeclaredValue :: SDL_DUMMY_ENUM
minDeclaredValue = SDL_DUMMY_ENUM
DUMMY_ENUM_VALUE

  maxDeclaredValue :: SDL_DUMMY_ENUM
maxDeclaredValue = SDL_DUMMY_ENUM
DUMMY_ENUM_VALUE

instance Show SDL_DUMMY_ENUM where
  showsPrec :: Int -> SDL_DUMMY_ENUM -> ShowS
showsPrec = Int -> SDL_DUMMY_ENUM -> ShowS
forall a. CEnum a => Int -> a -> ShowS
CEnum.shows

instance Read SDL_DUMMY_ENUM where
  readPrec :: ReadPrec SDL_DUMMY_ENUM
readPrec = ReadPrec SDL_DUMMY_ENUM
forall a. CEnum a => ReadPrec a
CEnum.readPrec

  readList :: ReadS [SDL_DUMMY_ENUM]
readList = ReadS [SDL_DUMMY_ENUM]
forall a. Read a => ReadS [a]
BG.readListDefault

  readListPrec :: ReadPrec [SDL_DUMMY_ENUM]
readListPrec = ReadPrec [SDL_DUMMY_ENUM]
forall a. Read a => ReadPrec [a]
BG.readListPrecDefault

instance
  (ty ~ BG.CUInt)
  => BG.CompatHasField.HasField "unwrap" SDL_DUMMY_ENUM ty
  where
  hasField :: SDL_DUMMY_ENUM -> (ty -> SDL_DUMMY_ENUM, ty)
hasField =
    \SDL_DUMMY_ENUM
x0 ->
      ( \ty
y1 ->
          SDL_DUMMY_ENUM{unwrap :: CUInt
unwrap = ty
CUInt
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_DUMMY_ENUM
x0
      )

instance
  (ty ~ BG.CUInt)
  => BG.HasField "unwrap" (BG.Ptr SDL_DUMMY_ENUM) (BG.Ptr ty)
  where
  getField :: Ptr SDL_DUMMY_ENUM -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_DUMMY_ENUM -> Ptr (CFieldType SDL_DUMMY_ENUM "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_DUMMY_ENUM "unwrap" where
  type CFieldType SDL_DUMMY_ENUM "unwrap" = BG.CUInt

  offset# :: Proxy# SDL_DUMMY_ENUM -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_DUMMY_ENUM
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | [C declaration]: @DUMMY_ENUM_VALUE@, defined at @SDL3\/SDL_stdinc.h 1204:5@
pattern DUMMY_ENUM_VALUE :: SDL_DUMMY_ENUM
pattern $mDUMMY_ENUM_VALUE :: forall {r}. SDL_DUMMY_ENUM -> ((# #) -> r) -> ((# #) -> r) -> r
$bDUMMY_ENUM_VALUE :: SDL_DUMMY_ENUM
DUMMY_ENUM_VALUE = SDL_DUMMY_ENUM 0

-- | Auxiliary type used by 'SDL_malloc_func'
--
--     [C declaration]: @SDL_malloc_func@, defined at @SDL3\/SDL_stdinc.h 1446:25@
newtype SDL_malloc_func_Aux = SDL_malloc_func_Aux
  { SDL_malloc_func_Aux -> CSize -> IO (Ptr Void)
unwrap :: HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)
  }
  deriving stock ((forall x. SDL_malloc_func_Aux -> Rep SDL_malloc_func_Aux x)
-> (forall x. Rep SDL_malloc_func_Aux x -> SDL_malloc_func_Aux)
-> Generic SDL_malloc_func_Aux
forall x. Rep SDL_malloc_func_Aux x -> SDL_malloc_func_Aux
forall x. SDL_malloc_func_Aux -> Rep SDL_malloc_func_Aux x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_malloc_func_Aux -> Rep SDL_malloc_func_Aux x
from :: forall x. SDL_malloc_func_Aux -> Rep SDL_malloc_func_Aux x
$cto :: forall x. Rep SDL_malloc_func_Aux x -> SDL_malloc_func_Aux
to :: forall x. Rep SDL_malloc_func_Aux x -> SDL_malloc_func_Aux
BG.Generic)

-- __unique:__ @toSDL_malloc_func_Aux@
foreign import ccall safe "wrapper"
  hs_bindgen_5c5a0694498aea22_base
    :: (HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void))
    -> IO (BG.FunPtr (HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)))

-- __unique:__ @toSDL_malloc_func_Aux@
hs_bindgen_5c5a0694498aea22
  :: SDL_malloc_func_Aux
  -> IO (BG.FunPtr SDL_malloc_func_Aux)
hs_bindgen_5c5a0694498aea22 :: SDL_malloc_func_Aux -> IO (FunPtr SDL_malloc_func_Aux)
hs_bindgen_5c5a0694498aea22 =
  \SDL_malloc_func_Aux
fun0 ->
    (FunPtr (CSize -> IO (Ptr Void)) -> FunPtr SDL_malloc_func_Aux)
-> IO (FunPtr (CSize -> IO (Ptr Void)))
-> IO (FunPtr SDL_malloc_func_Aux)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
      FunPtr (CSize -> IO (Ptr Void)) -> FunPtr SDL_malloc_func_Aux
forall a b. FunPtr a -> FunPtr b
BG.castFunPtr
      ( (CSize -> IO (Ptr Void)) -> IO (FunPtr (CSize -> IO (Ptr Void)))
hs_bindgen_5c5a0694498aea22_base
          ( \CSize
x1 ->
              (Ptr Void -> Ptr Void) -> IO (Ptr Void) -> IO (Ptr Void)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ptr Void -> Ptr Void
Ptr Void -> FFIType (Ptr Void)
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType (forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_malloc_func_Aux
fun0 (FFIType CSize -> CSize
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType CSize
FFIType CSize
x1))
          )
      )

-- __unique:__ @fromSDL_malloc_func_Aux@
foreign import ccall safe "dynamic"
  hs_bindgen_3dfc01b3bec18b2f_base
    :: BG.FunPtr (HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void))
    -> HsBindgen.Runtime.LibC.CSize
    -> IO (BG.Ptr BG.Void)

-- __unique:__ @fromSDL_malloc_func_Aux@
hs_bindgen_3dfc01b3bec18b2f
  :: BG.FunPtr SDL_malloc_func_Aux
  -> SDL_malloc_func_Aux
hs_bindgen_3dfc01b3bec18b2f :: FunPtr SDL_malloc_func_Aux -> SDL_malloc_func_Aux
hs_bindgen_3dfc01b3bec18b2f =
  \FunPtr SDL_malloc_func_Aux
funPtr0 ->
    (CSize -> IO (Ptr Void)) -> SDL_malloc_func_Aux
SDL_malloc_func_Aux
      ( \CSize
x1 ->
          (Ptr Void -> Ptr Void) -> IO (Ptr Void) -> IO (Ptr Void)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ptr Void -> Ptr Void
FFIType (Ptr Void) -> Ptr Void
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType (FunPtr (CSize -> IO (Ptr Void)) -> CSize -> IO (Ptr Void)
hs_bindgen_3dfc01b3bec18b2f_base (FunPtr SDL_malloc_func_Aux -> FunPtr (CSize -> IO (Ptr Void))
forall a b. FunPtr a -> FunPtr b
BG.castFunPtr FunPtr SDL_malloc_func_Aux
funPtr0) (CSize -> FFIType CSize
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType CSize
x1))
      )

instance BG.ToFunPtr SDL_malloc_func_Aux where
  toFunPtr :: SDL_malloc_func_Aux -> IO (FunPtr SDL_malloc_func_Aux)
toFunPtr = SDL_malloc_func_Aux -> IO (FunPtr SDL_malloc_func_Aux)
hs_bindgen_5c5a0694498aea22

instance BG.FromFunPtr SDL_malloc_func_Aux where
  fromFunPtr :: FunPtr SDL_malloc_func_Aux -> SDL_malloc_func_Aux
fromFunPtr = FunPtr SDL_malloc_func_Aux -> SDL_malloc_func_Aux
hs_bindgen_3dfc01b3bec18b2f

instance
  (ty ~ (HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)))
  => BG.CompatHasField.HasField "unwrap" SDL_malloc_func_Aux ty
  where
  hasField :: SDL_malloc_func_Aux -> (ty -> SDL_malloc_func_Aux, ty)
hasField =
    \SDL_malloc_func_Aux
x0 ->
      ( \ty
y1 ->
          SDL_malloc_func_Aux{unwrap :: CSize -> IO (Ptr Void)
unwrap = ty
CSize -> IO (Ptr Void)
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_malloc_func_Aux
x0
      )

instance
  (ty ~ (HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)))
  => BG.HasField "unwrap" (BG.Ptr SDL_malloc_func_Aux) (BG.Ptr ty)
  where
  getField :: Ptr SDL_malloc_func_Aux -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_malloc_func_Aux
-> Ptr (CFieldType SDL_malloc_func_Aux "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_malloc_func_Aux "unwrap" where
  type
    CFieldType SDL_malloc_func_Aux "unwrap" =
      HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)

  offset# :: Proxy# SDL_malloc_func_Aux -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_malloc_func_Aux
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | A callback used to implement @SDL_malloc()@.
--
--     SDL will always ensure that the passed @size@ is greater than 0.
--
--     [@size@]: the size to allocate.
--
--     [Returns]: a pointer to the allocated memory, or NULL if allocation failed.
--
--     [Thread safety]: It should be safe to call this callback from any thread.
--
--     @since 3.2.0
--
--     [See also]: 'sDL_malloc', 'sDL_GetOriginalMemoryFunctions', 'sDL_GetMemoryFunctions', 'sDL_SetMemoryFunctions'
--
--     [C declaration]: @SDL_malloc_func@, defined at @SDL3\/SDL_stdinc.h 1446:25@
newtype SDL_malloc_func = SDL_malloc_func
  { SDL_malloc_func -> FunPtr SDL_malloc_func_Aux
unwrap :: BG.FunPtr SDL_malloc_func_Aux
  }
  deriving stock ((forall x. SDL_malloc_func -> Rep SDL_malloc_func x)
-> (forall x. Rep SDL_malloc_func x -> SDL_malloc_func)
-> Generic SDL_malloc_func
forall x. Rep SDL_malloc_func x -> SDL_malloc_func
forall x. SDL_malloc_func -> Rep SDL_malloc_func x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_malloc_func -> Rep SDL_malloc_func x
from :: forall x. SDL_malloc_func -> Rep SDL_malloc_func x
$cto :: forall x. Rep SDL_malloc_func x -> SDL_malloc_func
to :: forall x. Rep SDL_malloc_func x -> SDL_malloc_func
BG.Generic, SDL_malloc_func -> SDL_malloc_func -> Bool
(SDL_malloc_func -> SDL_malloc_func -> Bool)
-> (SDL_malloc_func -> SDL_malloc_func -> Bool)
-> Eq SDL_malloc_func
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SDL_malloc_func -> SDL_malloc_func -> Bool
== :: SDL_malloc_func -> SDL_malloc_func -> Bool
$c/= :: SDL_malloc_func -> SDL_malloc_func -> Bool
/= :: SDL_malloc_func -> SDL_malloc_func -> Bool
Eq, Eq SDL_malloc_func
Eq SDL_malloc_func =>
(SDL_malloc_func -> SDL_malloc_func -> Ordering)
-> (SDL_malloc_func -> SDL_malloc_func -> Bool)
-> (SDL_malloc_func -> SDL_malloc_func -> Bool)
-> (SDL_malloc_func -> SDL_malloc_func -> Bool)
-> (SDL_malloc_func -> SDL_malloc_func -> Bool)
-> (SDL_malloc_func -> SDL_malloc_func -> SDL_malloc_func)
-> (SDL_malloc_func -> SDL_malloc_func -> SDL_malloc_func)
-> Ord SDL_malloc_func
SDL_malloc_func -> SDL_malloc_func -> Bool
SDL_malloc_func -> SDL_malloc_func -> Ordering
SDL_malloc_func -> SDL_malloc_func -> SDL_malloc_func
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
$ccompare :: SDL_malloc_func -> SDL_malloc_func -> Ordering
compare :: SDL_malloc_func -> SDL_malloc_func -> Ordering
$c< :: SDL_malloc_func -> SDL_malloc_func -> Bool
< :: SDL_malloc_func -> SDL_malloc_func -> Bool
$c<= :: SDL_malloc_func -> SDL_malloc_func -> Bool
<= :: SDL_malloc_func -> SDL_malloc_func -> Bool
$c> :: SDL_malloc_func -> SDL_malloc_func -> Bool
> :: SDL_malloc_func -> SDL_malloc_func -> Bool
$c>= :: SDL_malloc_func -> SDL_malloc_func -> Bool
>= :: SDL_malloc_func -> SDL_malloc_func -> Bool
$cmax :: SDL_malloc_func -> SDL_malloc_func -> SDL_malloc_func
max :: SDL_malloc_func -> SDL_malloc_func -> SDL_malloc_func
$cmin :: SDL_malloc_func -> SDL_malloc_func -> SDL_malloc_func
min :: SDL_malloc_func -> SDL_malloc_func -> SDL_malloc_func
Ord, Int -> SDL_malloc_func -> ShowS
[SDL_malloc_func] -> ShowS
SDL_malloc_func -> String
(Int -> SDL_malloc_func -> ShowS)
-> (SDL_malloc_func -> String)
-> ([SDL_malloc_func] -> ShowS)
-> Show SDL_malloc_func
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SDL_malloc_func -> ShowS
showsPrec :: Int -> SDL_malloc_func -> ShowS
$cshow :: SDL_malloc_func -> String
show :: SDL_malloc_func -> String
$cshowList :: [SDL_malloc_func] -> ShowS
showList :: [SDL_malloc_func] -> ShowS
Show)
  deriving newtype
    ( FFIType SDL_malloc_func -> SDL_malloc_func
SDL_malloc_func -> FFIType SDL_malloc_func
(SDL_malloc_func -> FFIType SDL_malloc_func)
-> (FFIType SDL_malloc_func -> SDL_malloc_func)
-> HasFFIType SDL_malloc_func
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: SDL_malloc_func -> FFIType SDL_malloc_func
toFFIType :: SDL_malloc_func -> FFIType SDL_malloc_func
$cfromFFIType :: FFIType SDL_malloc_func -> SDL_malloc_func
fromFFIType :: FFIType SDL_malloc_func -> SDL_malloc_func
BG.HasFFIType
    , Ptr SDL_malloc_func -> IO SDL_malloc_func
Ptr SDL_malloc_func -> Int -> IO SDL_malloc_func
Ptr SDL_malloc_func -> Int -> SDL_malloc_func -> IO ()
Ptr SDL_malloc_func -> SDL_malloc_func -> IO ()
SDL_malloc_func -> Int
(SDL_malloc_func -> Int)
-> (SDL_malloc_func -> Int)
-> (Ptr SDL_malloc_func -> Int -> IO SDL_malloc_func)
-> (Ptr SDL_malloc_func -> Int -> SDL_malloc_func -> IO ())
-> (forall b. Ptr b -> Int -> IO SDL_malloc_func)
-> (forall b. Ptr b -> Int -> SDL_malloc_func -> IO ())
-> (Ptr SDL_malloc_func -> IO SDL_malloc_func)
-> (Ptr SDL_malloc_func -> SDL_malloc_func -> IO ())
-> Storable SDL_malloc_func
forall b. Ptr b -> Int -> IO SDL_malloc_func
forall b. Ptr b -> Int -> SDL_malloc_func -> 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
$csizeOf :: SDL_malloc_func -> Int
sizeOf :: SDL_malloc_func -> Int
$calignment :: SDL_malloc_func -> Int
alignment :: SDL_malloc_func -> Int
$cpeekElemOff :: Ptr SDL_malloc_func -> Int -> IO SDL_malloc_func
peekElemOff :: Ptr SDL_malloc_func -> Int -> IO SDL_malloc_func
$cpokeElemOff :: Ptr SDL_malloc_func -> Int -> SDL_malloc_func -> IO ()
pokeElemOff :: Ptr SDL_malloc_func -> Int -> SDL_malloc_func -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO SDL_malloc_func
peekByteOff :: forall b. Ptr b -> Int -> IO SDL_malloc_func
$cpokeByteOff :: forall b. Ptr b -> Int -> SDL_malloc_func -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> SDL_malloc_func -> IO ()
$cpeek :: Ptr SDL_malloc_func -> IO SDL_malloc_func
peek :: Ptr SDL_malloc_func -> IO SDL_malloc_func
$cpoke :: Ptr SDL_malloc_func -> SDL_malloc_func -> IO ()
poke :: Ptr SDL_malloc_func -> SDL_malloc_func -> IO ()
BG.Storable
    , Ptr SDL_malloc_func -> IO SDL_malloc_func
(Ptr SDL_malloc_func -> IO SDL_malloc_func)
-> ReadRaw SDL_malloc_func
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr SDL_malloc_func -> IO SDL_malloc_func
readRaw :: Ptr SDL_malloc_func -> IO SDL_malloc_func
Marshal.ReadRaw
    , Proxy SDL_malloc_func -> Int
(Proxy SDL_malloc_func -> Int)
-> (Proxy SDL_malloc_func -> Int) -> StaticSize SDL_malloc_func
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy SDL_malloc_func -> Int
staticSizeOf :: Proxy SDL_malloc_func -> Int
$cstaticAlignment :: Proxy SDL_malloc_func -> Int
staticAlignment :: Proxy SDL_malloc_func -> Int
Marshal.StaticSize
    , Ptr SDL_malloc_func -> SDL_malloc_func -> IO ()
(Ptr SDL_malloc_func -> SDL_malloc_func -> IO ())
-> WriteRaw SDL_malloc_func
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr SDL_malloc_func -> SDL_malloc_func -> IO ()
writeRaw :: Ptr SDL_malloc_func -> SDL_malloc_func -> IO ()
Marshal.WriteRaw
    )

instance
  (ty ~ BG.FunPtr SDL_malloc_func_Aux)
  => BG.CompatHasField.HasField "unwrap" SDL_malloc_func ty
  where
  hasField :: SDL_malloc_func -> (ty -> SDL_malloc_func, ty)
hasField =
    \SDL_malloc_func
x0 ->
      ( \ty
y1 ->
          SDL_malloc_func{unwrap :: FunPtr SDL_malloc_func_Aux
unwrap = ty
FunPtr SDL_malloc_func_Aux
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_malloc_func
x0
      )

instance
  (ty ~ BG.FunPtr SDL_malloc_func_Aux)
  => BG.HasField "unwrap" (BG.Ptr SDL_malloc_func) (BG.Ptr ty)
  where
  getField :: Ptr SDL_malloc_func -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_malloc_func -> Ptr (CFieldType SDL_malloc_func "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_malloc_func "unwrap" where
  type
    CFieldType SDL_malloc_func "unwrap" =
      BG.FunPtr SDL_malloc_func_Aux

  offset# :: Proxy# SDL_malloc_func -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_malloc_func
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | Auxiliary type used by 'SDL_calloc_func'
--
--     [C declaration]: @SDL_calloc_func@, defined at @SDL3\/SDL_stdinc.h 1467:25@
newtype SDL_calloc_func_Aux = SDL_calloc_func_Aux
  { SDL_calloc_func_Aux -> CSize -> CSize -> IO (Ptr Void)
unwrap :: HsBindgen.Runtime.LibC.CSize -> HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)
  }
  deriving stock ((forall x. SDL_calloc_func_Aux -> Rep SDL_calloc_func_Aux x)
-> (forall x. Rep SDL_calloc_func_Aux x -> SDL_calloc_func_Aux)
-> Generic SDL_calloc_func_Aux
forall x. Rep SDL_calloc_func_Aux x -> SDL_calloc_func_Aux
forall x. SDL_calloc_func_Aux -> Rep SDL_calloc_func_Aux x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_calloc_func_Aux -> Rep SDL_calloc_func_Aux x
from :: forall x. SDL_calloc_func_Aux -> Rep SDL_calloc_func_Aux x
$cto :: forall x. Rep SDL_calloc_func_Aux x -> SDL_calloc_func_Aux
to :: forall x. Rep SDL_calloc_func_Aux x -> SDL_calloc_func_Aux
BG.Generic)

-- __unique:__ @toSDL_calloc_func_Aux@
foreign import ccall safe "wrapper"
  hs_bindgen_e0fe0baaf22a9277_base
    :: (HsBindgen.Runtime.LibC.CSize -> HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void))
    -> IO (BG.FunPtr (HsBindgen.Runtime.LibC.CSize -> HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)))

-- __unique:__ @toSDL_calloc_func_Aux@
hs_bindgen_e0fe0baaf22a9277
  :: SDL_calloc_func_Aux
  -> IO (BG.FunPtr SDL_calloc_func_Aux)
hs_bindgen_e0fe0baaf22a9277 :: SDL_calloc_func_Aux -> IO (FunPtr SDL_calloc_func_Aux)
hs_bindgen_e0fe0baaf22a9277 =
  \SDL_calloc_func_Aux
fun0 ->
    (FunPtr (CSize -> CSize -> IO (Ptr Void))
 -> FunPtr SDL_calloc_func_Aux)
-> IO (FunPtr (CSize -> CSize -> IO (Ptr Void)))
-> IO (FunPtr SDL_calloc_func_Aux)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
      FunPtr (CSize -> CSize -> IO (Ptr Void))
-> FunPtr SDL_calloc_func_Aux
forall a b. FunPtr a -> FunPtr b
BG.castFunPtr
      ( (CSize -> CSize -> IO (Ptr Void))
-> IO (FunPtr (CSize -> CSize -> IO (Ptr Void)))
hs_bindgen_e0fe0baaf22a9277_base
          ( \CSize
x1 ->
              \CSize
x2 ->
                (Ptr Void -> Ptr Void) -> IO (Ptr Void) -> IO (Ptr Void)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ptr Void -> Ptr Void
Ptr Void -> FFIType (Ptr Void)
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType (forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_calloc_func_Aux
fun0 (FFIType CSize -> CSize
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType CSize
FFIType CSize
x1) (FFIType CSize -> CSize
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType CSize
FFIType CSize
x2))
          )
      )

-- __unique:__ @fromSDL_calloc_func_Aux@
foreign import ccall safe "dynamic"
  hs_bindgen_3046202e62b950f1_base
    :: BG.FunPtr (HsBindgen.Runtime.LibC.CSize -> HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void))
    -> HsBindgen.Runtime.LibC.CSize
    -> HsBindgen.Runtime.LibC.CSize
    -> IO (BG.Ptr BG.Void)

-- __unique:__ @fromSDL_calloc_func_Aux@
hs_bindgen_3046202e62b950f1
  :: BG.FunPtr SDL_calloc_func_Aux
  -> SDL_calloc_func_Aux
hs_bindgen_3046202e62b950f1 :: FunPtr SDL_calloc_func_Aux -> SDL_calloc_func_Aux
hs_bindgen_3046202e62b950f1 =
  \FunPtr SDL_calloc_func_Aux
funPtr0 ->
    (CSize -> CSize -> IO (Ptr Void)) -> SDL_calloc_func_Aux
SDL_calloc_func_Aux
      ( \CSize
x1 ->
          \CSize
x2 ->
            (Ptr Void -> Ptr Void) -> IO (Ptr Void) -> IO (Ptr Void)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
              Ptr Void -> Ptr Void
FFIType (Ptr Void) -> Ptr Void
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType
              (FunPtr (CSize -> CSize -> IO (Ptr Void))
-> CSize -> CSize -> IO (Ptr Void)
hs_bindgen_3046202e62b950f1_base (FunPtr SDL_calloc_func_Aux
-> FunPtr (CSize -> CSize -> IO (Ptr Void))
forall a b. FunPtr a -> FunPtr b
BG.castFunPtr FunPtr SDL_calloc_func_Aux
funPtr0) (CSize -> FFIType CSize
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType CSize
x1) (CSize -> FFIType CSize
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType CSize
x2))
      )

instance BG.ToFunPtr SDL_calloc_func_Aux where
  toFunPtr :: SDL_calloc_func_Aux -> IO (FunPtr SDL_calloc_func_Aux)
toFunPtr = SDL_calloc_func_Aux -> IO (FunPtr SDL_calloc_func_Aux)
hs_bindgen_e0fe0baaf22a9277

instance BG.FromFunPtr SDL_calloc_func_Aux where
  fromFunPtr :: FunPtr SDL_calloc_func_Aux -> SDL_calloc_func_Aux
fromFunPtr = FunPtr SDL_calloc_func_Aux -> SDL_calloc_func_Aux
hs_bindgen_3046202e62b950f1

instance
  (ty ~ (HsBindgen.Runtime.LibC.CSize -> HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)))
  => BG.CompatHasField.HasField "unwrap" SDL_calloc_func_Aux ty
  where
  hasField :: SDL_calloc_func_Aux -> (ty -> SDL_calloc_func_Aux, ty)
hasField =
    \SDL_calloc_func_Aux
x0 ->
      ( \ty
y1 ->
          SDL_calloc_func_Aux{unwrap :: CSize -> CSize -> IO (Ptr Void)
unwrap = ty
CSize -> CSize -> IO (Ptr Void)
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_calloc_func_Aux
x0
      )

instance
  (ty ~ (HsBindgen.Runtime.LibC.CSize -> HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)))
  => BG.HasField "unwrap" (BG.Ptr SDL_calloc_func_Aux) (BG.Ptr ty)
  where
  getField :: Ptr SDL_calloc_func_Aux -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_calloc_func_Aux
-> Ptr (CFieldType SDL_calloc_func_Aux "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_calloc_func_Aux "unwrap" where
  type
    CFieldType SDL_calloc_func_Aux "unwrap" =
      HsBindgen.Runtime.LibC.CSize -> HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)

  offset# :: Proxy# SDL_calloc_func_Aux -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_calloc_func_Aux
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | A callback used to implement SDL_calloc().
--
--     SDL will always ensure that the passed @nmemb@ and @size@ are both greater than 0.
--
--     [@nmemb@]: the number of elements in the array.
--
--     [@size@]: the size of each element of the array.
--
--     [Returns]: a pointer to the allocated array, or NULL if allocation failed.
--
--     [Thread safety]: It should be safe to call this callback from any thread.
--
--     @since 3.2.0
--
--     [See also]: SDL_calloc, 'sDL_GetOriginalMemoryFunctions', 'sDL_GetMemoryFunctions', 'sDL_SetMemoryFunctions'
--
--     [C declaration]: @SDL_calloc_func@, defined at @SDL3\/SDL_stdinc.h 1467:25@
newtype SDL_calloc_func = SDL_calloc_func
  { SDL_calloc_func -> FunPtr SDL_calloc_func_Aux
unwrap :: BG.FunPtr SDL_calloc_func_Aux
  }
  deriving stock ((forall x. SDL_calloc_func -> Rep SDL_calloc_func x)
-> (forall x. Rep SDL_calloc_func x -> SDL_calloc_func)
-> Generic SDL_calloc_func
forall x. Rep SDL_calloc_func x -> SDL_calloc_func
forall x. SDL_calloc_func -> Rep SDL_calloc_func x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_calloc_func -> Rep SDL_calloc_func x
from :: forall x. SDL_calloc_func -> Rep SDL_calloc_func x
$cto :: forall x. Rep SDL_calloc_func x -> SDL_calloc_func
to :: forall x. Rep SDL_calloc_func x -> SDL_calloc_func
BG.Generic, SDL_calloc_func -> SDL_calloc_func -> Bool
(SDL_calloc_func -> SDL_calloc_func -> Bool)
-> (SDL_calloc_func -> SDL_calloc_func -> Bool)
-> Eq SDL_calloc_func
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SDL_calloc_func -> SDL_calloc_func -> Bool
== :: SDL_calloc_func -> SDL_calloc_func -> Bool
$c/= :: SDL_calloc_func -> SDL_calloc_func -> Bool
/= :: SDL_calloc_func -> SDL_calloc_func -> Bool
Eq, Eq SDL_calloc_func
Eq SDL_calloc_func =>
(SDL_calloc_func -> SDL_calloc_func -> Ordering)
-> (SDL_calloc_func -> SDL_calloc_func -> Bool)
-> (SDL_calloc_func -> SDL_calloc_func -> Bool)
-> (SDL_calloc_func -> SDL_calloc_func -> Bool)
-> (SDL_calloc_func -> SDL_calloc_func -> Bool)
-> (SDL_calloc_func -> SDL_calloc_func -> SDL_calloc_func)
-> (SDL_calloc_func -> SDL_calloc_func -> SDL_calloc_func)
-> Ord SDL_calloc_func
SDL_calloc_func -> SDL_calloc_func -> Bool
SDL_calloc_func -> SDL_calloc_func -> Ordering
SDL_calloc_func -> SDL_calloc_func -> SDL_calloc_func
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
$ccompare :: SDL_calloc_func -> SDL_calloc_func -> Ordering
compare :: SDL_calloc_func -> SDL_calloc_func -> Ordering
$c< :: SDL_calloc_func -> SDL_calloc_func -> Bool
< :: SDL_calloc_func -> SDL_calloc_func -> Bool
$c<= :: SDL_calloc_func -> SDL_calloc_func -> Bool
<= :: SDL_calloc_func -> SDL_calloc_func -> Bool
$c> :: SDL_calloc_func -> SDL_calloc_func -> Bool
> :: SDL_calloc_func -> SDL_calloc_func -> Bool
$c>= :: SDL_calloc_func -> SDL_calloc_func -> Bool
>= :: SDL_calloc_func -> SDL_calloc_func -> Bool
$cmax :: SDL_calloc_func -> SDL_calloc_func -> SDL_calloc_func
max :: SDL_calloc_func -> SDL_calloc_func -> SDL_calloc_func
$cmin :: SDL_calloc_func -> SDL_calloc_func -> SDL_calloc_func
min :: SDL_calloc_func -> SDL_calloc_func -> SDL_calloc_func
Ord, Int -> SDL_calloc_func -> ShowS
[SDL_calloc_func] -> ShowS
SDL_calloc_func -> String
(Int -> SDL_calloc_func -> ShowS)
-> (SDL_calloc_func -> String)
-> ([SDL_calloc_func] -> ShowS)
-> Show SDL_calloc_func
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SDL_calloc_func -> ShowS
showsPrec :: Int -> SDL_calloc_func -> ShowS
$cshow :: SDL_calloc_func -> String
show :: SDL_calloc_func -> String
$cshowList :: [SDL_calloc_func] -> ShowS
showList :: [SDL_calloc_func] -> ShowS
Show)
  deriving newtype
    ( FFIType SDL_calloc_func -> SDL_calloc_func
SDL_calloc_func -> FFIType SDL_calloc_func
(SDL_calloc_func -> FFIType SDL_calloc_func)
-> (FFIType SDL_calloc_func -> SDL_calloc_func)
-> HasFFIType SDL_calloc_func
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: SDL_calloc_func -> FFIType SDL_calloc_func
toFFIType :: SDL_calloc_func -> FFIType SDL_calloc_func
$cfromFFIType :: FFIType SDL_calloc_func -> SDL_calloc_func
fromFFIType :: FFIType SDL_calloc_func -> SDL_calloc_func
BG.HasFFIType
    , Ptr SDL_calloc_func -> IO SDL_calloc_func
Ptr SDL_calloc_func -> Int -> IO SDL_calloc_func
Ptr SDL_calloc_func -> Int -> SDL_calloc_func -> IO ()
Ptr SDL_calloc_func -> SDL_calloc_func -> IO ()
SDL_calloc_func -> Int
(SDL_calloc_func -> Int)
-> (SDL_calloc_func -> Int)
-> (Ptr SDL_calloc_func -> Int -> IO SDL_calloc_func)
-> (Ptr SDL_calloc_func -> Int -> SDL_calloc_func -> IO ())
-> (forall b. Ptr b -> Int -> IO SDL_calloc_func)
-> (forall b. Ptr b -> Int -> SDL_calloc_func -> IO ())
-> (Ptr SDL_calloc_func -> IO SDL_calloc_func)
-> (Ptr SDL_calloc_func -> SDL_calloc_func -> IO ())
-> Storable SDL_calloc_func
forall b. Ptr b -> Int -> IO SDL_calloc_func
forall b. Ptr b -> Int -> SDL_calloc_func -> 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
$csizeOf :: SDL_calloc_func -> Int
sizeOf :: SDL_calloc_func -> Int
$calignment :: SDL_calloc_func -> Int
alignment :: SDL_calloc_func -> Int
$cpeekElemOff :: Ptr SDL_calloc_func -> Int -> IO SDL_calloc_func
peekElemOff :: Ptr SDL_calloc_func -> Int -> IO SDL_calloc_func
$cpokeElemOff :: Ptr SDL_calloc_func -> Int -> SDL_calloc_func -> IO ()
pokeElemOff :: Ptr SDL_calloc_func -> Int -> SDL_calloc_func -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO SDL_calloc_func
peekByteOff :: forall b. Ptr b -> Int -> IO SDL_calloc_func
$cpokeByteOff :: forall b. Ptr b -> Int -> SDL_calloc_func -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> SDL_calloc_func -> IO ()
$cpeek :: Ptr SDL_calloc_func -> IO SDL_calloc_func
peek :: Ptr SDL_calloc_func -> IO SDL_calloc_func
$cpoke :: Ptr SDL_calloc_func -> SDL_calloc_func -> IO ()
poke :: Ptr SDL_calloc_func -> SDL_calloc_func -> IO ()
BG.Storable
    , Ptr SDL_calloc_func -> IO SDL_calloc_func
(Ptr SDL_calloc_func -> IO SDL_calloc_func)
-> ReadRaw SDL_calloc_func
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr SDL_calloc_func -> IO SDL_calloc_func
readRaw :: Ptr SDL_calloc_func -> IO SDL_calloc_func
Marshal.ReadRaw
    , Proxy SDL_calloc_func -> Int
(Proxy SDL_calloc_func -> Int)
-> (Proxy SDL_calloc_func -> Int) -> StaticSize SDL_calloc_func
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy SDL_calloc_func -> Int
staticSizeOf :: Proxy SDL_calloc_func -> Int
$cstaticAlignment :: Proxy SDL_calloc_func -> Int
staticAlignment :: Proxy SDL_calloc_func -> Int
Marshal.StaticSize
    , Ptr SDL_calloc_func -> SDL_calloc_func -> IO ()
(Ptr SDL_calloc_func -> SDL_calloc_func -> IO ())
-> WriteRaw SDL_calloc_func
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr SDL_calloc_func -> SDL_calloc_func -> IO ()
writeRaw :: Ptr SDL_calloc_func -> SDL_calloc_func -> IO ()
Marshal.WriteRaw
    )

instance
  (ty ~ BG.FunPtr SDL_calloc_func_Aux)
  => BG.CompatHasField.HasField "unwrap" SDL_calloc_func ty
  where
  hasField :: SDL_calloc_func -> (ty -> SDL_calloc_func, ty)
hasField =
    \SDL_calloc_func
x0 ->
      ( \ty
y1 ->
          SDL_calloc_func{unwrap :: FunPtr SDL_calloc_func_Aux
unwrap = ty
FunPtr SDL_calloc_func_Aux
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_calloc_func
x0
      )

instance
  (ty ~ BG.FunPtr SDL_calloc_func_Aux)
  => BG.HasField "unwrap" (BG.Ptr SDL_calloc_func) (BG.Ptr ty)
  where
  getField :: Ptr SDL_calloc_func -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_calloc_func -> Ptr (CFieldType SDL_calloc_func "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_calloc_func "unwrap" where
  type
    CFieldType SDL_calloc_func "unwrap" =
      BG.FunPtr SDL_calloc_func_Aux

  offset# :: Proxy# SDL_calloc_func -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_calloc_func
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | Auxiliary type used by 'SDL_realloc_func'
--
--     [C declaration]: @SDL_realloc_func@, defined at @SDL3\/SDL_stdinc.h 1488:25@
newtype SDL_realloc_func_Aux = SDL_realloc_func_Aux
  { SDL_realloc_func_Aux -> Ptr Void -> CSize -> IO (Ptr Void)
unwrap :: BG.Ptr BG.Void -> HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)
  }
  deriving stock ((forall x. SDL_realloc_func_Aux -> Rep SDL_realloc_func_Aux x)
-> (forall x. Rep SDL_realloc_func_Aux x -> SDL_realloc_func_Aux)
-> Generic SDL_realloc_func_Aux
forall x. Rep SDL_realloc_func_Aux x -> SDL_realloc_func_Aux
forall x. SDL_realloc_func_Aux -> Rep SDL_realloc_func_Aux x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_realloc_func_Aux -> Rep SDL_realloc_func_Aux x
from :: forall x. SDL_realloc_func_Aux -> Rep SDL_realloc_func_Aux x
$cto :: forall x. Rep SDL_realloc_func_Aux x -> SDL_realloc_func_Aux
to :: forall x. Rep SDL_realloc_func_Aux x -> SDL_realloc_func_Aux
BG.Generic)

-- __unique:__ @toSDL_realloc_func_Aux@
foreign import ccall safe "wrapper"
  hs_bindgen_ae5f282d8127c075_base
    :: (BG.Ptr BG.Void -> HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void))
    -> IO (BG.FunPtr (BG.Ptr BG.Void -> HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)))

-- __unique:__ @toSDL_realloc_func_Aux@
hs_bindgen_ae5f282d8127c075
  :: SDL_realloc_func_Aux
  -> IO (BG.FunPtr SDL_realloc_func_Aux)
hs_bindgen_ae5f282d8127c075 :: SDL_realloc_func_Aux -> IO (FunPtr SDL_realloc_func_Aux)
hs_bindgen_ae5f282d8127c075 =
  \SDL_realloc_func_Aux
fun0 ->
    (FunPtr (Ptr Void -> CSize -> IO (Ptr Void))
 -> FunPtr SDL_realloc_func_Aux)
-> IO (FunPtr (Ptr Void -> CSize -> IO (Ptr Void)))
-> IO (FunPtr SDL_realloc_func_Aux)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
      FunPtr (Ptr Void -> CSize -> IO (Ptr Void))
-> FunPtr SDL_realloc_func_Aux
forall a b. FunPtr a -> FunPtr b
BG.castFunPtr
      ( (Ptr Void -> CSize -> IO (Ptr Void))
-> IO (FunPtr (Ptr Void -> CSize -> IO (Ptr Void)))
hs_bindgen_ae5f282d8127c075_base
          ( \Ptr Void
x1 ->
              \CSize
x2 ->
                (Ptr Void -> Ptr Void) -> IO (Ptr Void) -> IO (Ptr Void)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ptr Void -> Ptr Void
Ptr Void -> FFIType (Ptr Void)
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType (forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_realloc_func_Aux
fun0 (FFIType (Ptr Void) -> Ptr Void
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType Ptr Void
FFIType (Ptr Void)
x1) (FFIType CSize -> CSize
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType CSize
FFIType CSize
x2))
          )
      )

-- __unique:__ @fromSDL_realloc_func_Aux@
foreign import ccall safe "dynamic"
  hs_bindgen_60fef27e3e28e137_base
    :: BG.FunPtr (BG.Ptr BG.Void -> HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void))
    -> BG.Ptr BG.Void
    -> HsBindgen.Runtime.LibC.CSize
    -> IO (BG.Ptr BG.Void)

-- __unique:__ @fromSDL_realloc_func_Aux@
hs_bindgen_60fef27e3e28e137
  :: BG.FunPtr SDL_realloc_func_Aux
  -> SDL_realloc_func_Aux
hs_bindgen_60fef27e3e28e137 :: FunPtr SDL_realloc_func_Aux -> SDL_realloc_func_Aux
hs_bindgen_60fef27e3e28e137 =
  \FunPtr SDL_realloc_func_Aux
funPtr0 ->
    (Ptr Void -> CSize -> IO (Ptr Void)) -> SDL_realloc_func_Aux
SDL_realloc_func_Aux
      ( \Ptr Void
x1 ->
          \CSize
x2 ->
            (Ptr Void -> Ptr Void) -> IO (Ptr Void) -> IO (Ptr Void)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
              Ptr Void -> Ptr Void
FFIType (Ptr Void) -> Ptr Void
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType
              (FunPtr (Ptr Void -> CSize -> IO (Ptr Void))
-> Ptr Void -> CSize -> IO (Ptr Void)
hs_bindgen_60fef27e3e28e137_base (FunPtr SDL_realloc_func_Aux
-> FunPtr (Ptr Void -> CSize -> IO (Ptr Void))
forall a b. FunPtr a -> FunPtr b
BG.castFunPtr FunPtr SDL_realloc_func_Aux
funPtr0) (Ptr Void -> FFIType (Ptr Void)
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType Ptr Void
x1) (CSize -> FFIType CSize
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType CSize
x2))
      )

instance BG.ToFunPtr SDL_realloc_func_Aux where
  toFunPtr :: SDL_realloc_func_Aux -> IO (FunPtr SDL_realloc_func_Aux)
toFunPtr = SDL_realloc_func_Aux -> IO (FunPtr SDL_realloc_func_Aux)
hs_bindgen_ae5f282d8127c075

instance BG.FromFunPtr SDL_realloc_func_Aux where
  fromFunPtr :: FunPtr SDL_realloc_func_Aux -> SDL_realloc_func_Aux
fromFunPtr = FunPtr SDL_realloc_func_Aux -> SDL_realloc_func_Aux
hs_bindgen_60fef27e3e28e137

instance
  (ty ~ (BG.Ptr BG.Void -> HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)))
  => BG.CompatHasField.HasField "unwrap" SDL_realloc_func_Aux ty
  where
  hasField :: SDL_realloc_func_Aux -> (ty -> SDL_realloc_func_Aux, ty)
hasField =
    \SDL_realloc_func_Aux
x0 ->
      ( \ty
y1 ->
          SDL_realloc_func_Aux{unwrap :: Ptr Void -> CSize -> IO (Ptr Void)
unwrap = ty
Ptr Void -> CSize -> IO (Ptr Void)
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_realloc_func_Aux
x0
      )

instance
  (ty ~ (BG.Ptr BG.Void -> HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)))
  => BG.HasField "unwrap" (BG.Ptr SDL_realloc_func_Aux) (BG.Ptr ty)
  where
  getField :: Ptr SDL_realloc_func_Aux -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_realloc_func_Aux
-> Ptr (CFieldType SDL_realloc_func_Aux "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_realloc_func_Aux "unwrap" where
  type
    CFieldType SDL_realloc_func_Aux "unwrap" =
      BG.Ptr BG.Void -> HsBindgen.Runtime.LibC.CSize -> IO (BG.Ptr BG.Void)

  offset# :: Proxy# SDL_realloc_func_Aux -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_realloc_func_Aux
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | A callback used to implement SDL_realloc().
--
--     SDL will always ensure that the passed @size@ is greater than 0.
--
--     [@mem@]: a pointer to allocated memory to reallocate, or NULL.
--
--     [@size@]: the new size of the memory.
--
--     [Returns]: a pointer to the newly allocated memory, or NULL if allocation failed.
--
--     [Thread safety]: It should be safe to call this callback from any thread.
--
--     @since 3.2.0
--
--     [See also]: SDL_realloc, 'sDL_GetOriginalMemoryFunctions', 'sDL_GetMemoryFunctions', 'sDL_SetMemoryFunctions'
--
--     [C declaration]: @SDL_realloc_func@, defined at @SDL3\/SDL_stdinc.h 1488:25@
newtype SDL_realloc_func = SDL_realloc_func
  { SDL_realloc_func -> FunPtr SDL_realloc_func_Aux
unwrap :: BG.FunPtr SDL_realloc_func_Aux
  }
  deriving stock ((forall x. SDL_realloc_func -> Rep SDL_realloc_func x)
-> (forall x. Rep SDL_realloc_func x -> SDL_realloc_func)
-> Generic SDL_realloc_func
forall x. Rep SDL_realloc_func x -> SDL_realloc_func
forall x. SDL_realloc_func -> Rep SDL_realloc_func x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_realloc_func -> Rep SDL_realloc_func x
from :: forall x. SDL_realloc_func -> Rep SDL_realloc_func x
$cto :: forall x. Rep SDL_realloc_func x -> SDL_realloc_func
to :: forall x. Rep SDL_realloc_func x -> SDL_realloc_func
BG.Generic, SDL_realloc_func -> SDL_realloc_func -> Bool
(SDL_realloc_func -> SDL_realloc_func -> Bool)
-> (SDL_realloc_func -> SDL_realloc_func -> Bool)
-> Eq SDL_realloc_func
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SDL_realloc_func -> SDL_realloc_func -> Bool
== :: SDL_realloc_func -> SDL_realloc_func -> Bool
$c/= :: SDL_realloc_func -> SDL_realloc_func -> Bool
/= :: SDL_realloc_func -> SDL_realloc_func -> Bool
Eq, Eq SDL_realloc_func
Eq SDL_realloc_func =>
(SDL_realloc_func -> SDL_realloc_func -> Ordering)
-> (SDL_realloc_func -> SDL_realloc_func -> Bool)
-> (SDL_realloc_func -> SDL_realloc_func -> Bool)
-> (SDL_realloc_func -> SDL_realloc_func -> Bool)
-> (SDL_realloc_func -> SDL_realloc_func -> Bool)
-> (SDL_realloc_func -> SDL_realloc_func -> SDL_realloc_func)
-> (SDL_realloc_func -> SDL_realloc_func -> SDL_realloc_func)
-> Ord SDL_realloc_func
SDL_realloc_func -> SDL_realloc_func -> Bool
SDL_realloc_func -> SDL_realloc_func -> Ordering
SDL_realloc_func -> SDL_realloc_func -> SDL_realloc_func
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
$ccompare :: SDL_realloc_func -> SDL_realloc_func -> Ordering
compare :: SDL_realloc_func -> SDL_realloc_func -> Ordering
$c< :: SDL_realloc_func -> SDL_realloc_func -> Bool
< :: SDL_realloc_func -> SDL_realloc_func -> Bool
$c<= :: SDL_realloc_func -> SDL_realloc_func -> Bool
<= :: SDL_realloc_func -> SDL_realloc_func -> Bool
$c> :: SDL_realloc_func -> SDL_realloc_func -> Bool
> :: SDL_realloc_func -> SDL_realloc_func -> Bool
$c>= :: SDL_realloc_func -> SDL_realloc_func -> Bool
>= :: SDL_realloc_func -> SDL_realloc_func -> Bool
$cmax :: SDL_realloc_func -> SDL_realloc_func -> SDL_realloc_func
max :: SDL_realloc_func -> SDL_realloc_func -> SDL_realloc_func
$cmin :: SDL_realloc_func -> SDL_realloc_func -> SDL_realloc_func
min :: SDL_realloc_func -> SDL_realloc_func -> SDL_realloc_func
Ord, Int -> SDL_realloc_func -> ShowS
[SDL_realloc_func] -> ShowS
SDL_realloc_func -> String
(Int -> SDL_realloc_func -> ShowS)
-> (SDL_realloc_func -> String)
-> ([SDL_realloc_func] -> ShowS)
-> Show SDL_realloc_func
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SDL_realloc_func -> ShowS
showsPrec :: Int -> SDL_realloc_func -> ShowS
$cshow :: SDL_realloc_func -> String
show :: SDL_realloc_func -> String
$cshowList :: [SDL_realloc_func] -> ShowS
showList :: [SDL_realloc_func] -> ShowS
Show)
  deriving newtype
    ( FFIType SDL_realloc_func -> SDL_realloc_func
SDL_realloc_func -> FFIType SDL_realloc_func
(SDL_realloc_func -> FFIType SDL_realloc_func)
-> (FFIType SDL_realloc_func -> SDL_realloc_func)
-> HasFFIType SDL_realloc_func
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: SDL_realloc_func -> FFIType SDL_realloc_func
toFFIType :: SDL_realloc_func -> FFIType SDL_realloc_func
$cfromFFIType :: FFIType SDL_realloc_func -> SDL_realloc_func
fromFFIType :: FFIType SDL_realloc_func -> SDL_realloc_func
BG.HasFFIType
    , Ptr SDL_realloc_func -> IO SDL_realloc_func
Ptr SDL_realloc_func -> Int -> IO SDL_realloc_func
Ptr SDL_realloc_func -> Int -> SDL_realloc_func -> IO ()
Ptr SDL_realloc_func -> SDL_realloc_func -> IO ()
SDL_realloc_func -> Int
(SDL_realloc_func -> Int)
-> (SDL_realloc_func -> Int)
-> (Ptr SDL_realloc_func -> Int -> IO SDL_realloc_func)
-> (Ptr SDL_realloc_func -> Int -> SDL_realloc_func -> IO ())
-> (forall b. Ptr b -> Int -> IO SDL_realloc_func)
-> (forall b. Ptr b -> Int -> SDL_realloc_func -> IO ())
-> (Ptr SDL_realloc_func -> IO SDL_realloc_func)
-> (Ptr SDL_realloc_func -> SDL_realloc_func -> IO ())
-> Storable SDL_realloc_func
forall b. Ptr b -> Int -> IO SDL_realloc_func
forall b. Ptr b -> Int -> SDL_realloc_func -> 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
$csizeOf :: SDL_realloc_func -> Int
sizeOf :: SDL_realloc_func -> Int
$calignment :: SDL_realloc_func -> Int
alignment :: SDL_realloc_func -> Int
$cpeekElemOff :: Ptr SDL_realloc_func -> Int -> IO SDL_realloc_func
peekElemOff :: Ptr SDL_realloc_func -> Int -> IO SDL_realloc_func
$cpokeElemOff :: Ptr SDL_realloc_func -> Int -> SDL_realloc_func -> IO ()
pokeElemOff :: Ptr SDL_realloc_func -> Int -> SDL_realloc_func -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO SDL_realloc_func
peekByteOff :: forall b. Ptr b -> Int -> IO SDL_realloc_func
$cpokeByteOff :: forall b. Ptr b -> Int -> SDL_realloc_func -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> SDL_realloc_func -> IO ()
$cpeek :: Ptr SDL_realloc_func -> IO SDL_realloc_func
peek :: Ptr SDL_realloc_func -> IO SDL_realloc_func
$cpoke :: Ptr SDL_realloc_func -> SDL_realloc_func -> IO ()
poke :: Ptr SDL_realloc_func -> SDL_realloc_func -> IO ()
BG.Storable
    , Ptr SDL_realloc_func -> IO SDL_realloc_func
(Ptr SDL_realloc_func -> IO SDL_realloc_func)
-> ReadRaw SDL_realloc_func
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr SDL_realloc_func -> IO SDL_realloc_func
readRaw :: Ptr SDL_realloc_func -> IO SDL_realloc_func
Marshal.ReadRaw
    , Proxy SDL_realloc_func -> Int
(Proxy SDL_realloc_func -> Int)
-> (Proxy SDL_realloc_func -> Int) -> StaticSize SDL_realloc_func
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy SDL_realloc_func -> Int
staticSizeOf :: Proxy SDL_realloc_func -> Int
$cstaticAlignment :: Proxy SDL_realloc_func -> Int
staticAlignment :: Proxy SDL_realloc_func -> Int
Marshal.StaticSize
    , Ptr SDL_realloc_func -> SDL_realloc_func -> IO ()
(Ptr SDL_realloc_func -> SDL_realloc_func -> IO ())
-> WriteRaw SDL_realloc_func
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr SDL_realloc_func -> SDL_realloc_func -> IO ()
writeRaw :: Ptr SDL_realloc_func -> SDL_realloc_func -> IO ()
Marshal.WriteRaw
    )

instance
  (ty ~ BG.FunPtr SDL_realloc_func_Aux)
  => BG.CompatHasField.HasField "unwrap" SDL_realloc_func ty
  where
  hasField :: SDL_realloc_func -> (ty -> SDL_realloc_func, ty)
hasField =
    \SDL_realloc_func
x0 ->
      ( \ty
y1 ->
          SDL_realloc_func{unwrap :: FunPtr SDL_realloc_func_Aux
unwrap = ty
FunPtr SDL_realloc_func_Aux
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_realloc_func
x0
      )

instance
  (ty ~ BG.FunPtr SDL_realloc_func_Aux)
  => BG.HasField "unwrap" (BG.Ptr SDL_realloc_func) (BG.Ptr ty)
  where
  getField :: Ptr SDL_realloc_func -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_realloc_func
-> Ptr (CFieldType SDL_realloc_func "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_realloc_func "unwrap" where
  type
    CFieldType SDL_realloc_func "unwrap" =
      BG.FunPtr SDL_realloc_func_Aux

  offset# :: Proxy# SDL_realloc_func -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_realloc_func
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | Auxiliary type used by 'SDL_free_func'
--
--     [C declaration]: @SDL_free_func@, defined at @SDL3\/SDL_stdinc.h 1506:24@
newtype SDL_free_func_Aux = SDL_free_func_Aux
  { SDL_free_func_Aux -> Ptr Void -> IO ()
unwrap :: BG.Ptr BG.Void -> IO ()
  }
  deriving stock ((forall x. SDL_free_func_Aux -> Rep SDL_free_func_Aux x)
-> (forall x. Rep SDL_free_func_Aux x -> SDL_free_func_Aux)
-> Generic SDL_free_func_Aux
forall x. Rep SDL_free_func_Aux x -> SDL_free_func_Aux
forall x. SDL_free_func_Aux -> Rep SDL_free_func_Aux x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_free_func_Aux -> Rep SDL_free_func_Aux x
from :: forall x. SDL_free_func_Aux -> Rep SDL_free_func_Aux x
$cto :: forall x. Rep SDL_free_func_Aux x -> SDL_free_func_Aux
to :: forall x. Rep SDL_free_func_Aux x -> SDL_free_func_Aux
BG.Generic)

-- __unique:__ @toSDL_free_func_Aux@
foreign import ccall safe "wrapper"
  hs_bindgen_f13c0d9d2bec2096_base
    :: (BG.Ptr BG.Void -> IO ())
    -> IO (BG.FunPtr (BG.Ptr BG.Void -> IO ()))

-- __unique:__ @toSDL_free_func_Aux@
hs_bindgen_f13c0d9d2bec2096
  :: SDL_free_func_Aux
  -> IO (BG.FunPtr SDL_free_func_Aux)
hs_bindgen_f13c0d9d2bec2096 :: SDL_free_func_Aux -> IO (FunPtr SDL_free_func_Aux)
hs_bindgen_f13c0d9d2bec2096 =
  \SDL_free_func_Aux
fun0 ->
    (FunPtr (Ptr Void -> IO ()) -> FunPtr SDL_free_func_Aux)
-> IO (FunPtr (Ptr Void -> IO ())) -> IO (FunPtr SDL_free_func_Aux)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
      FunPtr (Ptr Void -> IO ()) -> FunPtr SDL_free_func_Aux
forall a b. FunPtr a -> FunPtr b
BG.castFunPtr
      ( (Ptr Void -> IO ()) -> IO (FunPtr (Ptr Void -> IO ()))
hs_bindgen_f13c0d9d2bec2096_base
          ( \Ptr Void
x1 ->
              forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_free_func_Aux
fun0 (FFIType (Ptr Void) -> Ptr Void
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType Ptr Void
FFIType (Ptr Void)
x1)
          )
      )

-- __unique:__ @fromSDL_free_func_Aux@
foreign import ccall safe "dynamic"
  hs_bindgen_05ceac4716402972_base
    :: BG.FunPtr (BG.Ptr BG.Void -> IO ())
    -> BG.Ptr BG.Void
    -> IO ()

-- __unique:__ @fromSDL_free_func_Aux@
hs_bindgen_05ceac4716402972
  :: BG.FunPtr SDL_free_func_Aux
  -> SDL_free_func_Aux
hs_bindgen_05ceac4716402972 :: FunPtr SDL_free_func_Aux -> SDL_free_func_Aux
hs_bindgen_05ceac4716402972 =
  \FunPtr SDL_free_func_Aux
funPtr0 ->
    (Ptr Void -> IO ()) -> SDL_free_func_Aux
SDL_free_func_Aux
      ( \Ptr Void
x1 ->
          FunPtr (Ptr Void -> IO ()) -> Ptr Void -> IO ()
hs_bindgen_05ceac4716402972_base (FunPtr SDL_free_func_Aux -> FunPtr (Ptr Void -> IO ())
forall a b. FunPtr a -> FunPtr b
BG.castFunPtr FunPtr SDL_free_func_Aux
funPtr0) (Ptr Void -> FFIType (Ptr Void)
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType Ptr Void
x1)
      )

instance BG.ToFunPtr SDL_free_func_Aux where
  toFunPtr :: SDL_free_func_Aux -> IO (FunPtr SDL_free_func_Aux)
toFunPtr = SDL_free_func_Aux -> IO (FunPtr SDL_free_func_Aux)
hs_bindgen_f13c0d9d2bec2096

instance BG.FromFunPtr SDL_free_func_Aux where
  fromFunPtr :: FunPtr SDL_free_func_Aux -> SDL_free_func_Aux
fromFunPtr = FunPtr SDL_free_func_Aux -> SDL_free_func_Aux
hs_bindgen_05ceac4716402972

instance
  (ty ~ (BG.Ptr BG.Void -> IO ()))
  => BG.CompatHasField.HasField "unwrap" SDL_free_func_Aux ty
  where
  hasField :: SDL_free_func_Aux -> (ty -> SDL_free_func_Aux, ty)
hasField =
    \SDL_free_func_Aux
x0 ->
      ( \ty
y1 ->
          SDL_free_func_Aux{unwrap :: Ptr Void -> IO ()
unwrap = ty
Ptr Void -> IO ()
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_free_func_Aux
x0
      )

instance
  (ty ~ (BG.Ptr BG.Void -> IO ()))
  => BG.HasField "unwrap" (BG.Ptr SDL_free_func_Aux) (BG.Ptr ty)
  where
  getField :: Ptr SDL_free_func_Aux -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_free_func_Aux
-> Ptr (CFieldType SDL_free_func_Aux "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_free_func_Aux "unwrap" where
  type
    CFieldType SDL_free_func_Aux "unwrap" =
      BG.Ptr BG.Void -> IO ()

  offset# :: Proxy# SDL_free_func_Aux -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_free_func_Aux
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | A callback used to implement @SDL_free()@.
--
--     SDL will always ensure that the passed @mem@ is a non-NULL pointer.
--
--     [@mem@]: a pointer to allocated memory.
--
--     [Thread safety]: It should be safe to call this callback from any thread.
--
--     @since 3.2.0
--
--     [See also]: 'sDL_free', 'sDL_GetOriginalMemoryFunctions', 'sDL_GetMemoryFunctions', 'sDL_SetMemoryFunctions'
--
--     [C declaration]: @SDL_free_func@, defined at @SDL3\/SDL_stdinc.h 1506:24@
newtype SDL_free_func = SDL_free_func
  { SDL_free_func -> FunPtr SDL_free_func_Aux
unwrap :: BG.FunPtr SDL_free_func_Aux
  }
  deriving stock ((forall x. SDL_free_func -> Rep SDL_free_func x)
-> (forall x. Rep SDL_free_func x -> SDL_free_func)
-> Generic SDL_free_func
forall x. Rep SDL_free_func x -> SDL_free_func
forall x. SDL_free_func -> Rep SDL_free_func x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_free_func -> Rep SDL_free_func x
from :: forall x. SDL_free_func -> Rep SDL_free_func x
$cto :: forall x. Rep SDL_free_func x -> SDL_free_func
to :: forall x. Rep SDL_free_func x -> SDL_free_func
BG.Generic, SDL_free_func -> SDL_free_func -> Bool
(SDL_free_func -> SDL_free_func -> Bool)
-> (SDL_free_func -> SDL_free_func -> Bool) -> Eq SDL_free_func
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SDL_free_func -> SDL_free_func -> Bool
== :: SDL_free_func -> SDL_free_func -> Bool
$c/= :: SDL_free_func -> SDL_free_func -> Bool
/= :: SDL_free_func -> SDL_free_func -> Bool
Eq, Eq SDL_free_func
Eq SDL_free_func =>
(SDL_free_func -> SDL_free_func -> Ordering)
-> (SDL_free_func -> SDL_free_func -> Bool)
-> (SDL_free_func -> SDL_free_func -> Bool)
-> (SDL_free_func -> SDL_free_func -> Bool)
-> (SDL_free_func -> SDL_free_func -> Bool)
-> (SDL_free_func -> SDL_free_func -> SDL_free_func)
-> (SDL_free_func -> SDL_free_func -> SDL_free_func)
-> Ord SDL_free_func
SDL_free_func -> SDL_free_func -> Bool
SDL_free_func -> SDL_free_func -> Ordering
SDL_free_func -> SDL_free_func -> SDL_free_func
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
$ccompare :: SDL_free_func -> SDL_free_func -> Ordering
compare :: SDL_free_func -> SDL_free_func -> Ordering
$c< :: SDL_free_func -> SDL_free_func -> Bool
< :: SDL_free_func -> SDL_free_func -> Bool
$c<= :: SDL_free_func -> SDL_free_func -> Bool
<= :: SDL_free_func -> SDL_free_func -> Bool
$c> :: SDL_free_func -> SDL_free_func -> Bool
> :: SDL_free_func -> SDL_free_func -> Bool
$c>= :: SDL_free_func -> SDL_free_func -> Bool
>= :: SDL_free_func -> SDL_free_func -> Bool
$cmax :: SDL_free_func -> SDL_free_func -> SDL_free_func
max :: SDL_free_func -> SDL_free_func -> SDL_free_func
$cmin :: SDL_free_func -> SDL_free_func -> SDL_free_func
min :: SDL_free_func -> SDL_free_func -> SDL_free_func
Ord, Int -> SDL_free_func -> ShowS
[SDL_free_func] -> ShowS
SDL_free_func -> String
(Int -> SDL_free_func -> ShowS)
-> (SDL_free_func -> String)
-> ([SDL_free_func] -> ShowS)
-> Show SDL_free_func
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SDL_free_func -> ShowS
showsPrec :: Int -> SDL_free_func -> ShowS
$cshow :: SDL_free_func -> String
show :: SDL_free_func -> String
$cshowList :: [SDL_free_func] -> ShowS
showList :: [SDL_free_func] -> ShowS
Show)
  deriving newtype
    ( FFIType SDL_free_func -> SDL_free_func
SDL_free_func -> FFIType SDL_free_func
(SDL_free_func -> FFIType SDL_free_func)
-> (FFIType SDL_free_func -> SDL_free_func)
-> HasFFIType SDL_free_func
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: SDL_free_func -> FFIType SDL_free_func
toFFIType :: SDL_free_func -> FFIType SDL_free_func
$cfromFFIType :: FFIType SDL_free_func -> SDL_free_func
fromFFIType :: FFIType SDL_free_func -> SDL_free_func
BG.HasFFIType
    , Ptr SDL_free_func -> IO SDL_free_func
Ptr SDL_free_func -> Int -> IO SDL_free_func
Ptr SDL_free_func -> Int -> SDL_free_func -> IO ()
Ptr SDL_free_func -> SDL_free_func -> IO ()
SDL_free_func -> Int
(SDL_free_func -> Int)
-> (SDL_free_func -> Int)
-> (Ptr SDL_free_func -> Int -> IO SDL_free_func)
-> (Ptr SDL_free_func -> Int -> SDL_free_func -> IO ())
-> (forall b. Ptr b -> Int -> IO SDL_free_func)
-> (forall b. Ptr b -> Int -> SDL_free_func -> IO ())
-> (Ptr SDL_free_func -> IO SDL_free_func)
-> (Ptr SDL_free_func -> SDL_free_func -> IO ())
-> Storable SDL_free_func
forall b. Ptr b -> Int -> IO SDL_free_func
forall b. Ptr b -> Int -> SDL_free_func -> 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
$csizeOf :: SDL_free_func -> Int
sizeOf :: SDL_free_func -> Int
$calignment :: SDL_free_func -> Int
alignment :: SDL_free_func -> Int
$cpeekElemOff :: Ptr SDL_free_func -> Int -> IO SDL_free_func
peekElemOff :: Ptr SDL_free_func -> Int -> IO SDL_free_func
$cpokeElemOff :: Ptr SDL_free_func -> Int -> SDL_free_func -> IO ()
pokeElemOff :: Ptr SDL_free_func -> Int -> SDL_free_func -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO SDL_free_func
peekByteOff :: forall b. Ptr b -> Int -> IO SDL_free_func
$cpokeByteOff :: forall b. Ptr b -> Int -> SDL_free_func -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> SDL_free_func -> IO ()
$cpeek :: Ptr SDL_free_func -> IO SDL_free_func
peek :: Ptr SDL_free_func -> IO SDL_free_func
$cpoke :: Ptr SDL_free_func -> SDL_free_func -> IO ()
poke :: Ptr SDL_free_func -> SDL_free_func -> IO ()
BG.Storable
    , Ptr SDL_free_func -> IO SDL_free_func
(Ptr SDL_free_func -> IO SDL_free_func) -> ReadRaw SDL_free_func
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr SDL_free_func -> IO SDL_free_func
readRaw :: Ptr SDL_free_func -> IO SDL_free_func
Marshal.ReadRaw
    , Proxy SDL_free_func -> Int
(Proxy SDL_free_func -> Int)
-> (Proxy SDL_free_func -> Int) -> StaticSize SDL_free_func
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy SDL_free_func -> Int
staticSizeOf :: Proxy SDL_free_func -> Int
$cstaticAlignment :: Proxy SDL_free_func -> Int
staticAlignment :: Proxy SDL_free_func -> Int
Marshal.StaticSize
    , Ptr SDL_free_func -> SDL_free_func -> IO ()
(Ptr SDL_free_func -> SDL_free_func -> IO ())
-> WriteRaw SDL_free_func
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr SDL_free_func -> SDL_free_func -> IO ()
writeRaw :: Ptr SDL_free_func -> SDL_free_func -> IO ()
Marshal.WriteRaw
    )

instance
  (ty ~ BG.FunPtr SDL_free_func_Aux)
  => BG.CompatHasField.HasField "unwrap" SDL_free_func ty
  where
  hasField :: SDL_free_func -> (ty -> SDL_free_func, ty)
hasField =
    \SDL_free_func
x0 ->
      ( \ty
y1 ->
          SDL_free_func{unwrap :: FunPtr SDL_free_func_Aux
unwrap = ty
FunPtr SDL_free_func_Aux
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_free_func
x0
      )

instance
  (ty ~ BG.FunPtr SDL_free_func_Aux)
  => BG.HasField "unwrap" (BG.Ptr SDL_free_func) (BG.Ptr ty)
  where
  getField :: Ptr SDL_free_func -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_free_func -> Ptr (CFieldType SDL_free_func "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_free_func "unwrap" where
  type
    CFieldType SDL_free_func "unwrap" =
      BG.FunPtr SDL_free_func_Aux

  offset# :: Proxy# SDL_free_func -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_free_func
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | A thread-safe set of environment variables
--
--     @since 3.2.0
--
--     [See also]: 'sDL_GetEnvironment', 'sDL_CreateEnvironment', 'sDL_GetEnvironmentVariable', 'sDL_GetEnvironmentVariables', 'sDL_SetEnvironmentVariable', 'sDL_UnsetEnvironmentVariable', 'sDL_DestroyEnvironment'
--
--     [C declaration]: @struct SDL_Environment@, defined at @SDL3\/SDL_stdinc.h 1650:16@
data SDL_Environment

-- | Auxiliary type used by 'SDL_CompareCallback'
--
--     [C declaration]: @SDL_CompareCallback@, defined at @SDL3\/SDL_stdinc.h 1885:23@
newtype SDL_CompareCallback_Aux = SDL_CompareCallback_Aux
  { SDL_CompareCallback_Aux
-> PtrConst Void -> PtrConst Void -> IO CInt
unwrap :: PtrConst.PtrConst BG.Void -> PtrConst.PtrConst BG.Void -> IO BG.CInt
  }
  deriving stock ((forall x.
 SDL_CompareCallback_Aux -> Rep SDL_CompareCallback_Aux x)
-> (forall x.
    Rep SDL_CompareCallback_Aux x -> SDL_CompareCallback_Aux)
-> Generic SDL_CompareCallback_Aux
forall x. Rep SDL_CompareCallback_Aux x -> SDL_CompareCallback_Aux
forall x. SDL_CompareCallback_Aux -> Rep SDL_CompareCallback_Aux x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_CompareCallback_Aux -> Rep SDL_CompareCallback_Aux x
from :: forall x. SDL_CompareCallback_Aux -> Rep SDL_CompareCallback_Aux x
$cto :: forall x. Rep SDL_CompareCallback_Aux x -> SDL_CompareCallback_Aux
to :: forall x. Rep SDL_CompareCallback_Aux x -> SDL_CompareCallback_Aux
BG.Generic)

-- __unique:__ @toSDL_CompareCallback_Aux@
foreign import ccall safe "wrapper"
  hs_bindgen_b4335f7e8ef40f79_base
    :: (BG.Ptr BG.Void -> BG.Ptr BG.Void -> IO BG.CInt)
    -> IO (BG.FunPtr (BG.Ptr BG.Void -> BG.Ptr BG.Void -> IO BG.CInt))

-- __unique:__ @toSDL_CompareCallback_Aux@
hs_bindgen_b4335f7e8ef40f79
  :: SDL_CompareCallback_Aux
  -> IO (BG.FunPtr SDL_CompareCallback_Aux)
hs_bindgen_b4335f7e8ef40f79 :: SDL_CompareCallback_Aux -> IO (FunPtr SDL_CompareCallback_Aux)
hs_bindgen_b4335f7e8ef40f79 =
  \SDL_CompareCallback_Aux
fun0 ->
    (FunPtr (Ptr Void -> Ptr Void -> IO CInt)
 -> FunPtr SDL_CompareCallback_Aux)
-> IO (FunPtr (Ptr Void -> Ptr Void -> IO CInt))
-> IO (FunPtr SDL_CompareCallback_Aux)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
      FunPtr (Ptr Void -> Ptr Void -> IO CInt)
-> FunPtr SDL_CompareCallback_Aux
forall a b. FunPtr a -> FunPtr b
BG.castFunPtr
      ( (Ptr Void -> Ptr Void -> IO CInt)
-> IO (FunPtr (Ptr Void -> Ptr Void -> IO CInt))
hs_bindgen_b4335f7e8ef40f79_base
          ( \Ptr Void
x1 ->
              \Ptr Void
x2 ->
                (CInt -> CInt) -> IO CInt -> IO CInt
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CInt -> CInt
CInt -> FFIType CInt
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType (forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_CompareCallback_Aux
fun0 (FFIType (PtrConst Void) -> PtrConst Void
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType Ptr Void
FFIType (PtrConst Void)
x1) (FFIType (PtrConst Void) -> PtrConst Void
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType Ptr Void
FFIType (PtrConst Void)
x2))
          )
      )

-- __unique:__ @fromSDL_CompareCallback_Aux@
foreign import ccall safe "dynamic"
  hs_bindgen_72d385fa3e33955d_base
    :: BG.FunPtr (BG.Ptr BG.Void -> BG.Ptr BG.Void -> IO BG.CInt)
    -> BG.Ptr BG.Void
    -> BG.Ptr BG.Void
    -> IO BG.CInt

-- __unique:__ @fromSDL_CompareCallback_Aux@
hs_bindgen_72d385fa3e33955d
  :: BG.FunPtr SDL_CompareCallback_Aux
  -> SDL_CompareCallback_Aux
hs_bindgen_72d385fa3e33955d :: FunPtr SDL_CompareCallback_Aux -> SDL_CompareCallback_Aux
hs_bindgen_72d385fa3e33955d =
  \FunPtr SDL_CompareCallback_Aux
funPtr0 ->
    (PtrConst Void -> PtrConst Void -> IO CInt)
-> SDL_CompareCallback_Aux
SDL_CompareCallback_Aux
      ( \PtrConst Void
x1 ->
          \PtrConst Void
x2 ->
            (CInt -> CInt) -> IO CInt -> IO CInt
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
              CInt -> CInt
FFIType CInt -> CInt
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType
              (FunPtr (Ptr Void -> Ptr Void -> IO CInt)
-> Ptr Void -> Ptr Void -> IO CInt
hs_bindgen_72d385fa3e33955d_base (FunPtr SDL_CompareCallback_Aux
-> FunPtr (Ptr Void -> Ptr Void -> IO CInt)
forall a b. FunPtr a -> FunPtr b
BG.castFunPtr FunPtr SDL_CompareCallback_Aux
funPtr0) (PtrConst Void -> FFIType (PtrConst Void)
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType PtrConst Void
x1) (PtrConst Void -> FFIType (PtrConst Void)
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType PtrConst Void
x2))
      )

instance BG.ToFunPtr SDL_CompareCallback_Aux where
  toFunPtr :: SDL_CompareCallback_Aux -> IO (FunPtr SDL_CompareCallback_Aux)
toFunPtr = SDL_CompareCallback_Aux -> IO (FunPtr SDL_CompareCallback_Aux)
hs_bindgen_b4335f7e8ef40f79

instance BG.FromFunPtr SDL_CompareCallback_Aux where
  fromFunPtr :: FunPtr SDL_CompareCallback_Aux -> SDL_CompareCallback_Aux
fromFunPtr = FunPtr SDL_CompareCallback_Aux -> SDL_CompareCallback_Aux
hs_bindgen_72d385fa3e33955d

instance
  (ty ~ (PtrConst.PtrConst BG.Void -> PtrConst.PtrConst BG.Void -> IO BG.CInt))
  => BG.CompatHasField.HasField "unwrap" SDL_CompareCallback_Aux ty
  where
  hasField :: SDL_CompareCallback_Aux -> (ty -> SDL_CompareCallback_Aux, ty)
hasField =
    \SDL_CompareCallback_Aux
x0 ->
      ( \ty
y1 ->
          SDL_CompareCallback_Aux{unwrap :: PtrConst Void -> PtrConst Void -> IO CInt
unwrap = ty
PtrConst Void -> PtrConst Void -> IO CInt
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_CompareCallback_Aux
x0
      )

instance
  (ty ~ (PtrConst.PtrConst BG.Void -> PtrConst.PtrConst BG.Void -> IO BG.CInt))
  => BG.HasField "unwrap" (BG.Ptr SDL_CompareCallback_Aux) (BG.Ptr ty)
  where
  getField :: Ptr SDL_CompareCallback_Aux -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_CompareCallback_Aux
-> Ptr (CFieldType SDL_CompareCallback_Aux "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_CompareCallback_Aux "unwrap" where
  type
    CFieldType SDL_CompareCallback_Aux "unwrap" =
      PtrConst.PtrConst BG.Void -> PtrConst.PtrConst BG.Void -> IO BG.CInt

  offset# :: Proxy# SDL_CompareCallback_Aux -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_CompareCallback_Aux
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | A callback used with SDL sorting and binary search functions.
--
--     [@a@]: a pointer to the first element being compared.
--
--     [@b@]: a pointer to the second element being compared.
--
--     [Returns]: -1 if @a@ should be sorted before @b@, 1 if @b@ should be sorted before @a@, 0 if they are equal. If two elements are equal, their order in the sorted array is undefined.
--
--     @since 3.2.0
--
--     [See also]: 'sDL_bsearch', 'sDL_qsort'
--
--     [C declaration]: @SDL_CompareCallback@, defined at @SDL3\/SDL_stdinc.h 1885:23@
newtype SDL_CompareCallback = SDL_CompareCallback
  { SDL_CompareCallback -> FunPtr SDL_CompareCallback_Aux
unwrap :: BG.FunPtr SDL_CompareCallback_Aux
  }
  deriving stock ((forall x. SDL_CompareCallback -> Rep SDL_CompareCallback x)
-> (forall x. Rep SDL_CompareCallback x -> SDL_CompareCallback)
-> Generic SDL_CompareCallback
forall x. Rep SDL_CompareCallback x -> SDL_CompareCallback
forall x. SDL_CompareCallback -> Rep SDL_CompareCallback x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_CompareCallback -> Rep SDL_CompareCallback x
from :: forall x. SDL_CompareCallback -> Rep SDL_CompareCallback x
$cto :: forall x. Rep SDL_CompareCallback x -> SDL_CompareCallback
to :: forall x. Rep SDL_CompareCallback x -> SDL_CompareCallback
BG.Generic, SDL_CompareCallback -> SDL_CompareCallback -> Bool
(SDL_CompareCallback -> SDL_CompareCallback -> Bool)
-> (SDL_CompareCallback -> SDL_CompareCallback -> Bool)
-> Eq SDL_CompareCallback
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SDL_CompareCallback -> SDL_CompareCallback -> Bool
== :: SDL_CompareCallback -> SDL_CompareCallback -> Bool
$c/= :: SDL_CompareCallback -> SDL_CompareCallback -> Bool
/= :: SDL_CompareCallback -> SDL_CompareCallback -> Bool
Eq, Eq SDL_CompareCallback
Eq SDL_CompareCallback =>
(SDL_CompareCallback -> SDL_CompareCallback -> Ordering)
-> (SDL_CompareCallback -> SDL_CompareCallback -> Bool)
-> (SDL_CompareCallback -> SDL_CompareCallback -> Bool)
-> (SDL_CompareCallback -> SDL_CompareCallback -> Bool)
-> (SDL_CompareCallback -> SDL_CompareCallback -> Bool)
-> (SDL_CompareCallback
    -> SDL_CompareCallback -> SDL_CompareCallback)
-> (SDL_CompareCallback
    -> SDL_CompareCallback -> SDL_CompareCallback)
-> Ord SDL_CompareCallback
SDL_CompareCallback -> SDL_CompareCallback -> Bool
SDL_CompareCallback -> SDL_CompareCallback -> Ordering
SDL_CompareCallback -> SDL_CompareCallback -> SDL_CompareCallback
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
$ccompare :: SDL_CompareCallback -> SDL_CompareCallback -> Ordering
compare :: SDL_CompareCallback -> SDL_CompareCallback -> Ordering
$c< :: SDL_CompareCallback -> SDL_CompareCallback -> Bool
< :: SDL_CompareCallback -> SDL_CompareCallback -> Bool
$c<= :: SDL_CompareCallback -> SDL_CompareCallback -> Bool
<= :: SDL_CompareCallback -> SDL_CompareCallback -> Bool
$c> :: SDL_CompareCallback -> SDL_CompareCallback -> Bool
> :: SDL_CompareCallback -> SDL_CompareCallback -> Bool
$c>= :: SDL_CompareCallback -> SDL_CompareCallback -> Bool
>= :: SDL_CompareCallback -> SDL_CompareCallback -> Bool
$cmax :: SDL_CompareCallback -> SDL_CompareCallback -> SDL_CompareCallback
max :: SDL_CompareCallback -> SDL_CompareCallback -> SDL_CompareCallback
$cmin :: SDL_CompareCallback -> SDL_CompareCallback -> SDL_CompareCallback
min :: SDL_CompareCallback -> SDL_CompareCallback -> SDL_CompareCallback
Ord, Int -> SDL_CompareCallback -> ShowS
[SDL_CompareCallback] -> ShowS
SDL_CompareCallback -> String
(Int -> SDL_CompareCallback -> ShowS)
-> (SDL_CompareCallback -> String)
-> ([SDL_CompareCallback] -> ShowS)
-> Show SDL_CompareCallback
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SDL_CompareCallback -> ShowS
showsPrec :: Int -> SDL_CompareCallback -> ShowS
$cshow :: SDL_CompareCallback -> String
show :: SDL_CompareCallback -> String
$cshowList :: [SDL_CompareCallback] -> ShowS
showList :: [SDL_CompareCallback] -> ShowS
Show)
  deriving newtype
    ( FFIType SDL_CompareCallback -> SDL_CompareCallback
SDL_CompareCallback -> FFIType SDL_CompareCallback
(SDL_CompareCallback -> FFIType SDL_CompareCallback)
-> (FFIType SDL_CompareCallback -> SDL_CompareCallback)
-> HasFFIType SDL_CompareCallback
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: SDL_CompareCallback -> FFIType SDL_CompareCallback
toFFIType :: SDL_CompareCallback -> FFIType SDL_CompareCallback
$cfromFFIType :: FFIType SDL_CompareCallback -> SDL_CompareCallback
fromFFIType :: FFIType SDL_CompareCallback -> SDL_CompareCallback
BG.HasFFIType
    , Ptr SDL_CompareCallback -> IO SDL_CompareCallback
Ptr SDL_CompareCallback -> Int -> IO SDL_CompareCallback
Ptr SDL_CompareCallback -> Int -> SDL_CompareCallback -> IO ()
Ptr SDL_CompareCallback -> SDL_CompareCallback -> IO ()
SDL_CompareCallback -> Int
(SDL_CompareCallback -> Int)
-> (SDL_CompareCallback -> Int)
-> (Ptr SDL_CompareCallback -> Int -> IO SDL_CompareCallback)
-> (Ptr SDL_CompareCallback -> Int -> SDL_CompareCallback -> IO ())
-> (forall b. Ptr b -> Int -> IO SDL_CompareCallback)
-> (forall b. Ptr b -> Int -> SDL_CompareCallback -> IO ())
-> (Ptr SDL_CompareCallback -> IO SDL_CompareCallback)
-> (Ptr SDL_CompareCallback -> SDL_CompareCallback -> IO ())
-> Storable SDL_CompareCallback
forall b. Ptr b -> Int -> IO SDL_CompareCallback
forall b. Ptr b -> Int -> SDL_CompareCallback -> 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
$csizeOf :: SDL_CompareCallback -> Int
sizeOf :: SDL_CompareCallback -> Int
$calignment :: SDL_CompareCallback -> Int
alignment :: SDL_CompareCallback -> Int
$cpeekElemOff :: Ptr SDL_CompareCallback -> Int -> IO SDL_CompareCallback
peekElemOff :: Ptr SDL_CompareCallback -> Int -> IO SDL_CompareCallback
$cpokeElemOff :: Ptr SDL_CompareCallback -> Int -> SDL_CompareCallback -> IO ()
pokeElemOff :: Ptr SDL_CompareCallback -> Int -> SDL_CompareCallback -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO SDL_CompareCallback
peekByteOff :: forall b. Ptr b -> Int -> IO SDL_CompareCallback
$cpokeByteOff :: forall b. Ptr b -> Int -> SDL_CompareCallback -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> SDL_CompareCallback -> IO ()
$cpeek :: Ptr SDL_CompareCallback -> IO SDL_CompareCallback
peek :: Ptr SDL_CompareCallback -> IO SDL_CompareCallback
$cpoke :: Ptr SDL_CompareCallback -> SDL_CompareCallback -> IO ()
poke :: Ptr SDL_CompareCallback -> SDL_CompareCallback -> IO ()
BG.Storable
    , Ptr SDL_CompareCallback -> IO SDL_CompareCallback
(Ptr SDL_CompareCallback -> IO SDL_CompareCallback)
-> ReadRaw SDL_CompareCallback
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr SDL_CompareCallback -> IO SDL_CompareCallback
readRaw :: Ptr SDL_CompareCallback -> IO SDL_CompareCallback
Marshal.ReadRaw
    , Proxy SDL_CompareCallback -> Int
(Proxy SDL_CompareCallback -> Int)
-> (Proxy SDL_CompareCallback -> Int)
-> StaticSize SDL_CompareCallback
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy SDL_CompareCallback -> Int
staticSizeOf :: Proxy SDL_CompareCallback -> Int
$cstaticAlignment :: Proxy SDL_CompareCallback -> Int
staticAlignment :: Proxy SDL_CompareCallback -> Int
Marshal.StaticSize
    , Ptr SDL_CompareCallback -> SDL_CompareCallback -> IO ()
(Ptr SDL_CompareCallback -> SDL_CompareCallback -> IO ())
-> WriteRaw SDL_CompareCallback
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr SDL_CompareCallback -> SDL_CompareCallback -> IO ()
writeRaw :: Ptr SDL_CompareCallback -> SDL_CompareCallback -> IO ()
Marshal.WriteRaw
    )

instance
  (ty ~ BG.FunPtr SDL_CompareCallback_Aux)
  => BG.CompatHasField.HasField "unwrap" SDL_CompareCallback ty
  where
  hasField :: SDL_CompareCallback -> (ty -> SDL_CompareCallback, ty)
hasField =
    \SDL_CompareCallback
x0 ->
      ( \ty
y1 ->
          SDL_CompareCallback{unwrap :: FunPtr SDL_CompareCallback_Aux
unwrap = ty
FunPtr SDL_CompareCallback_Aux
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_CompareCallback
x0
      )

instance
  (ty ~ BG.FunPtr SDL_CompareCallback_Aux)
  => BG.HasField "unwrap" (BG.Ptr SDL_CompareCallback) (BG.Ptr ty)
  where
  getField :: Ptr SDL_CompareCallback -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_CompareCallback
-> Ptr (CFieldType SDL_CompareCallback "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_CompareCallback "unwrap" where
  type
    CFieldType SDL_CompareCallback "unwrap" =
      BG.FunPtr SDL_CompareCallback_Aux

  offset# :: Proxy# SDL_CompareCallback -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_CompareCallback
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | Auxiliary type used by 'SDL_CompareCallback_r'
--
--     [C declaration]: @SDL_CompareCallback_r@, defined at @SDL3\/SDL_stdinc.h 1998:23@
newtype SDL_CompareCallback_r_Aux = SDL_CompareCallback_r_Aux
  { SDL_CompareCallback_r_Aux
-> Ptr Void -> PtrConst Void -> PtrConst Void -> IO CInt
unwrap :: BG.Ptr BG.Void -> PtrConst.PtrConst BG.Void -> PtrConst.PtrConst BG.Void -> IO BG.CInt
  }
  deriving stock ((forall x.
 SDL_CompareCallback_r_Aux -> Rep SDL_CompareCallback_r_Aux x)
-> (forall x.
    Rep SDL_CompareCallback_r_Aux x -> SDL_CompareCallback_r_Aux)
-> Generic SDL_CompareCallback_r_Aux
forall x.
Rep SDL_CompareCallback_r_Aux x -> SDL_CompareCallback_r_Aux
forall x.
SDL_CompareCallback_r_Aux -> Rep SDL_CompareCallback_r_Aux x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
SDL_CompareCallback_r_Aux -> Rep SDL_CompareCallback_r_Aux x
from :: forall x.
SDL_CompareCallback_r_Aux -> Rep SDL_CompareCallback_r_Aux x
$cto :: forall x.
Rep SDL_CompareCallback_r_Aux x -> SDL_CompareCallback_r_Aux
to :: forall x.
Rep SDL_CompareCallback_r_Aux x -> SDL_CompareCallback_r_Aux
BG.Generic)

-- __unique:__ @toSDL_CompareCallback_r_Aux@
foreign import ccall safe "wrapper"
  hs_bindgen_a12f359999653344_base
    :: (BG.Ptr BG.Void -> BG.Ptr BG.Void -> BG.Ptr BG.Void -> IO BG.CInt)
    -> IO (BG.FunPtr (BG.Ptr BG.Void -> BG.Ptr BG.Void -> BG.Ptr BG.Void -> IO BG.CInt))

-- __unique:__ @toSDL_CompareCallback_r_Aux@
hs_bindgen_a12f359999653344
  :: SDL_CompareCallback_r_Aux
  -> IO (BG.FunPtr SDL_CompareCallback_r_Aux)
hs_bindgen_a12f359999653344 :: SDL_CompareCallback_r_Aux -> IO (FunPtr SDL_CompareCallback_r_Aux)
hs_bindgen_a12f359999653344 =
  \SDL_CompareCallback_r_Aux
fun0 ->
    (FunPtr (Ptr Void -> Ptr Void -> Ptr Void -> IO CInt)
 -> FunPtr SDL_CompareCallback_r_Aux)
-> IO (FunPtr (Ptr Void -> Ptr Void -> Ptr Void -> IO CInt))
-> IO (FunPtr SDL_CompareCallback_r_Aux)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
      FunPtr (Ptr Void -> Ptr Void -> Ptr Void -> IO CInt)
-> FunPtr SDL_CompareCallback_r_Aux
forall a b. FunPtr a -> FunPtr b
BG.castFunPtr
      ( (Ptr Void -> Ptr Void -> Ptr Void -> IO CInt)
-> IO (FunPtr (Ptr Void -> Ptr Void -> Ptr Void -> IO CInt))
hs_bindgen_a12f359999653344_base
          ( \Ptr Void
x1 ->
              \Ptr Void
x2 ->
                \Ptr Void
x3 ->
                  (CInt -> CInt) -> IO CInt -> IO CInt
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
                    CInt -> CInt
CInt -> FFIType CInt
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType
                    (forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_CompareCallback_r_Aux
fun0 (FFIType (Ptr Void) -> Ptr Void
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType Ptr Void
FFIType (Ptr Void)
x1) (FFIType (PtrConst Void) -> PtrConst Void
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType Ptr Void
FFIType (PtrConst Void)
x2) (FFIType (PtrConst Void) -> PtrConst Void
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType Ptr Void
FFIType (PtrConst Void)
x3))
          )
      )

-- __unique:__ @fromSDL_CompareCallback_r_Aux@
foreign import ccall safe "dynamic"
  hs_bindgen_c41d0998fdad0a16_base
    :: BG.FunPtr (BG.Ptr BG.Void -> BG.Ptr BG.Void -> BG.Ptr BG.Void -> IO BG.CInt)
    -> BG.Ptr BG.Void
    -> BG.Ptr BG.Void
    -> BG.Ptr BG.Void
    -> IO BG.CInt

-- __unique:__ @fromSDL_CompareCallback_r_Aux@
hs_bindgen_c41d0998fdad0a16
  :: BG.FunPtr SDL_CompareCallback_r_Aux
  -> SDL_CompareCallback_r_Aux
hs_bindgen_c41d0998fdad0a16 :: FunPtr SDL_CompareCallback_r_Aux -> SDL_CompareCallback_r_Aux
hs_bindgen_c41d0998fdad0a16 =
  \FunPtr SDL_CompareCallback_r_Aux
funPtr0 ->
    (Ptr Void -> PtrConst Void -> PtrConst Void -> IO CInt)
-> SDL_CompareCallback_r_Aux
SDL_CompareCallback_r_Aux
      ( \Ptr Void
x1 ->
          \PtrConst Void
x2 ->
            \PtrConst Void
x3 ->
              (CInt -> CInt) -> IO CInt -> IO CInt
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
                CInt -> CInt
FFIType CInt -> CInt
forall a. HasFFIType a => FFIType a -> a
BG.fromFFIType
                ( FunPtr (Ptr Void -> Ptr Void -> Ptr Void -> IO CInt)
-> Ptr Void -> Ptr Void -> Ptr Void -> IO CInt
hs_bindgen_c41d0998fdad0a16_base
                    (FunPtr SDL_CompareCallback_r_Aux
-> FunPtr (Ptr Void -> Ptr Void -> Ptr Void -> IO CInt)
forall a b. FunPtr a -> FunPtr b
BG.castFunPtr FunPtr SDL_CompareCallback_r_Aux
funPtr0)
                    (Ptr Void -> FFIType (Ptr Void)
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType Ptr Void
x1)
                    (PtrConst Void -> FFIType (PtrConst Void)
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType PtrConst Void
x2)
                    (PtrConst Void -> FFIType (PtrConst Void)
forall a. HasFFIType a => a -> FFIType a
BG.toFFIType PtrConst Void
x3)
                )
      )

instance BG.ToFunPtr SDL_CompareCallback_r_Aux where
  toFunPtr :: SDL_CompareCallback_r_Aux -> IO (FunPtr SDL_CompareCallback_r_Aux)
toFunPtr = SDL_CompareCallback_r_Aux -> IO (FunPtr SDL_CompareCallback_r_Aux)
hs_bindgen_a12f359999653344

instance BG.FromFunPtr SDL_CompareCallback_r_Aux where
  fromFunPtr :: FunPtr SDL_CompareCallback_r_Aux -> SDL_CompareCallback_r_Aux
fromFunPtr = FunPtr SDL_CompareCallback_r_Aux -> SDL_CompareCallback_r_Aux
hs_bindgen_c41d0998fdad0a16

instance
  (ty ~ (BG.Ptr BG.Void -> PtrConst.PtrConst BG.Void -> PtrConst.PtrConst BG.Void -> IO BG.CInt))
  => BG.CompatHasField.HasField "unwrap" SDL_CompareCallback_r_Aux ty
  where
  hasField :: SDL_CompareCallback_r_Aux -> (ty -> SDL_CompareCallback_r_Aux, ty)
hasField =
    \SDL_CompareCallback_r_Aux
x0 ->
      ( \ty
y1 ->
          SDL_CompareCallback_r_Aux{unwrap :: Ptr Void -> PtrConst Void -> PtrConst Void -> IO CInt
unwrap = ty
Ptr Void -> PtrConst Void -> PtrConst Void -> IO CInt
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_CompareCallback_r_Aux
x0
      )

instance
  (ty ~ (BG.Ptr BG.Void -> PtrConst.PtrConst BG.Void -> PtrConst.PtrConst BG.Void -> IO BG.CInt))
  => BG.HasField "unwrap" (BG.Ptr SDL_CompareCallback_r_Aux) (BG.Ptr ty)
  where
  getField :: Ptr SDL_CompareCallback_r_Aux -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_CompareCallback_r_Aux
-> Ptr (CFieldType SDL_CompareCallback_r_Aux "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_CompareCallback_r_Aux "unwrap" where
  type
    CFieldType SDL_CompareCallback_r_Aux "unwrap" =
      BG.Ptr BG.Void -> PtrConst.PtrConst BG.Void -> PtrConst.PtrConst BG.Void -> IO BG.CInt

  offset# :: Proxy# SDL_CompareCallback_r_Aux -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_CompareCallback_r_Aux
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | A callback used with SDL sorting and binary search functions.
--
--     [@userdata@]: the @userdata@ pointer passed to the sort function.
--
--     [@a@]: a pointer to the first element being compared.
--
--     [@b@]: a pointer to the second element being compared.
--
--     [Returns]: -1 if @a@ should be sorted before @b@, 1 if @b@ should be sorted before @a@, 0 if they are equal. If two elements are equal, their order in the sorted array is undefined.
--
--     @since 3.2.0
--
--     [See also]: 'sDL_qsort_r', 'sDL_bsearch_r'
--
--     [C declaration]: @SDL_CompareCallback_r@, defined at @SDL3\/SDL_stdinc.h 1998:23@
newtype SDL_CompareCallback_r = SDL_CompareCallback_r
  { SDL_CompareCallback_r -> FunPtr SDL_CompareCallback_r_Aux
unwrap :: BG.FunPtr SDL_CompareCallback_r_Aux
  }
  deriving stock ((forall x. SDL_CompareCallback_r -> Rep SDL_CompareCallback_r x)
-> (forall x. Rep SDL_CompareCallback_r x -> SDL_CompareCallback_r)
-> Generic SDL_CompareCallback_r
forall x. Rep SDL_CompareCallback_r x -> SDL_CompareCallback_r
forall x. SDL_CompareCallback_r -> Rep SDL_CompareCallback_r x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_CompareCallback_r -> Rep SDL_CompareCallback_r x
from :: forall x. SDL_CompareCallback_r -> Rep SDL_CompareCallback_r x
$cto :: forall x. Rep SDL_CompareCallback_r x -> SDL_CompareCallback_r
to :: forall x. Rep SDL_CompareCallback_r x -> SDL_CompareCallback_r
BG.Generic, SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool
(SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool)
-> (SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool)
-> Eq SDL_CompareCallback_r
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool
== :: SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool
$c/= :: SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool
/= :: SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool
Eq, Eq SDL_CompareCallback_r
Eq SDL_CompareCallback_r =>
(SDL_CompareCallback_r -> SDL_CompareCallback_r -> Ordering)
-> (SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool)
-> (SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool)
-> (SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool)
-> (SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool)
-> (SDL_CompareCallback_r
    -> SDL_CompareCallback_r -> SDL_CompareCallback_r)
-> (SDL_CompareCallback_r
    -> SDL_CompareCallback_r -> SDL_CompareCallback_r)
-> Ord SDL_CompareCallback_r
SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool
SDL_CompareCallback_r -> SDL_CompareCallback_r -> Ordering
SDL_CompareCallback_r
-> SDL_CompareCallback_r -> SDL_CompareCallback_r
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
$ccompare :: SDL_CompareCallback_r -> SDL_CompareCallback_r -> Ordering
compare :: SDL_CompareCallback_r -> SDL_CompareCallback_r -> Ordering
$c< :: SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool
< :: SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool
$c<= :: SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool
<= :: SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool
$c> :: SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool
> :: SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool
$c>= :: SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool
>= :: SDL_CompareCallback_r -> SDL_CompareCallback_r -> Bool
$cmax :: SDL_CompareCallback_r
-> SDL_CompareCallback_r -> SDL_CompareCallback_r
max :: SDL_CompareCallback_r
-> SDL_CompareCallback_r -> SDL_CompareCallback_r
$cmin :: SDL_CompareCallback_r
-> SDL_CompareCallback_r -> SDL_CompareCallback_r
min :: SDL_CompareCallback_r
-> SDL_CompareCallback_r -> SDL_CompareCallback_r
Ord, Int -> SDL_CompareCallback_r -> ShowS
[SDL_CompareCallback_r] -> ShowS
SDL_CompareCallback_r -> String
(Int -> SDL_CompareCallback_r -> ShowS)
-> (SDL_CompareCallback_r -> String)
-> ([SDL_CompareCallback_r] -> ShowS)
-> Show SDL_CompareCallback_r
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SDL_CompareCallback_r -> ShowS
showsPrec :: Int -> SDL_CompareCallback_r -> ShowS
$cshow :: SDL_CompareCallback_r -> String
show :: SDL_CompareCallback_r -> String
$cshowList :: [SDL_CompareCallback_r] -> ShowS
showList :: [SDL_CompareCallback_r] -> ShowS
Show)
  deriving newtype
    ( FFIType SDL_CompareCallback_r -> SDL_CompareCallback_r
SDL_CompareCallback_r -> FFIType SDL_CompareCallback_r
(SDL_CompareCallback_r -> FFIType SDL_CompareCallback_r)
-> (FFIType SDL_CompareCallback_r -> SDL_CompareCallback_r)
-> HasFFIType SDL_CompareCallback_r
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: SDL_CompareCallback_r -> FFIType SDL_CompareCallback_r
toFFIType :: SDL_CompareCallback_r -> FFIType SDL_CompareCallback_r
$cfromFFIType :: FFIType SDL_CompareCallback_r -> SDL_CompareCallback_r
fromFFIType :: FFIType SDL_CompareCallback_r -> SDL_CompareCallback_r
BG.HasFFIType
    , Ptr SDL_CompareCallback_r -> IO SDL_CompareCallback_r
Ptr SDL_CompareCallback_r -> Int -> IO SDL_CompareCallback_r
Ptr SDL_CompareCallback_r -> Int -> SDL_CompareCallback_r -> IO ()
Ptr SDL_CompareCallback_r -> SDL_CompareCallback_r -> IO ()
SDL_CompareCallback_r -> Int
(SDL_CompareCallback_r -> Int)
-> (SDL_CompareCallback_r -> Int)
-> (Ptr SDL_CompareCallback_r -> Int -> IO SDL_CompareCallback_r)
-> (Ptr SDL_CompareCallback_r
    -> Int -> SDL_CompareCallback_r -> IO ())
-> (forall b. Ptr b -> Int -> IO SDL_CompareCallback_r)
-> (forall b. Ptr b -> Int -> SDL_CompareCallback_r -> IO ())
-> (Ptr SDL_CompareCallback_r -> IO SDL_CompareCallback_r)
-> (Ptr SDL_CompareCallback_r -> SDL_CompareCallback_r -> IO ())
-> Storable SDL_CompareCallback_r
forall b. Ptr b -> Int -> IO SDL_CompareCallback_r
forall b. Ptr b -> Int -> SDL_CompareCallback_r -> 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
$csizeOf :: SDL_CompareCallback_r -> Int
sizeOf :: SDL_CompareCallback_r -> Int
$calignment :: SDL_CompareCallback_r -> Int
alignment :: SDL_CompareCallback_r -> Int
$cpeekElemOff :: Ptr SDL_CompareCallback_r -> Int -> IO SDL_CompareCallback_r
peekElemOff :: Ptr SDL_CompareCallback_r -> Int -> IO SDL_CompareCallback_r
$cpokeElemOff :: Ptr SDL_CompareCallback_r -> Int -> SDL_CompareCallback_r -> IO ()
pokeElemOff :: Ptr SDL_CompareCallback_r -> Int -> SDL_CompareCallback_r -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO SDL_CompareCallback_r
peekByteOff :: forall b. Ptr b -> Int -> IO SDL_CompareCallback_r
$cpokeByteOff :: forall b. Ptr b -> Int -> SDL_CompareCallback_r -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> SDL_CompareCallback_r -> IO ()
$cpeek :: Ptr SDL_CompareCallback_r -> IO SDL_CompareCallback_r
peek :: Ptr SDL_CompareCallback_r -> IO SDL_CompareCallback_r
$cpoke :: Ptr SDL_CompareCallback_r -> SDL_CompareCallback_r -> IO ()
poke :: Ptr SDL_CompareCallback_r -> SDL_CompareCallback_r -> IO ()
BG.Storable
    , Ptr SDL_CompareCallback_r -> IO SDL_CompareCallback_r
(Ptr SDL_CompareCallback_r -> IO SDL_CompareCallback_r)
-> ReadRaw SDL_CompareCallback_r
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr SDL_CompareCallback_r -> IO SDL_CompareCallback_r
readRaw :: Ptr SDL_CompareCallback_r -> IO SDL_CompareCallback_r
Marshal.ReadRaw
    , Proxy SDL_CompareCallback_r -> Int
(Proxy SDL_CompareCallback_r -> Int)
-> (Proxy SDL_CompareCallback_r -> Int)
-> StaticSize SDL_CompareCallback_r
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy SDL_CompareCallback_r -> Int
staticSizeOf :: Proxy SDL_CompareCallback_r -> Int
$cstaticAlignment :: Proxy SDL_CompareCallback_r -> Int
staticAlignment :: Proxy SDL_CompareCallback_r -> Int
Marshal.StaticSize
    , Ptr SDL_CompareCallback_r -> SDL_CompareCallback_r -> IO ()
(Ptr SDL_CompareCallback_r -> SDL_CompareCallback_r -> IO ())
-> WriteRaw SDL_CompareCallback_r
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr SDL_CompareCallback_r -> SDL_CompareCallback_r -> IO ()
writeRaw :: Ptr SDL_CompareCallback_r -> SDL_CompareCallback_r -> IO ()
Marshal.WriteRaw
    )

instance
  (ty ~ BG.FunPtr SDL_CompareCallback_r_Aux)
  => BG.CompatHasField.HasField "unwrap" SDL_CompareCallback_r ty
  where
  hasField :: SDL_CompareCallback_r -> (ty -> SDL_CompareCallback_r, ty)
hasField =
    \SDL_CompareCallback_r
x0 ->
      ( \ty
y1 ->
          SDL_CompareCallback_r{unwrap :: FunPtr SDL_CompareCallback_r_Aux
unwrap = ty
FunPtr SDL_CompareCallback_r_Aux
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_CompareCallback_r
x0
      )

instance
  (ty ~ BG.FunPtr SDL_CompareCallback_r_Aux)
  => BG.HasField "unwrap" (BG.Ptr SDL_CompareCallback_r) (BG.Ptr ty)
  where
  getField :: Ptr SDL_CompareCallback_r -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_CompareCallback_r
-> Ptr (CFieldType SDL_CompareCallback_r "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_CompareCallback_r "unwrap" where
  type
    CFieldType SDL_CompareCallback_r "unwrap" =
      BG.FunPtr SDL_CompareCallback_r_Aux

  offset# :: Proxy# SDL_CompareCallback_r -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_CompareCallback_r
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | The Unicode REPLACEMENT CHARACTER codepoint.
--
--     @SDL_StepUTF8()@ and @SDL_StepBackUTF8()@ report this codepoint when they encounter a UTF-8 string with encoding errors.
--
--     This tends to render as something like a question mark in most places.
--
--     @since 3.2.0
--
--     [See also]: 'sDL_StepBackUTF8', 'sDL_StepUTF8'
--
--     [C declaration]: @macro SDL_INVALID_UNICODE_CODEPOINT@, defined at @SDL3\/SDL_stdinc.h 3985:9@
sDL_INVALID_UNICODE_CODEPOINT :: BG.CInt
sDL_INVALID_UNICODE_CODEPOINT :: CInt
sDL_INVALID_UNICODE_CODEPOINT = (CInt
65533 :: BG.CInt)

-- | The value of Pi, as a double-precision floating point literal.
--
--     @since 3.2.0
--
--     [See also]: 'sDL_PI_F' pi (double)
--
--     [C declaration]: @macro SDL_PI_D@, defined at @SDL3\/SDL_stdinc.h 4480:9@
sDL_PI_D :: BG.CDouble
sDL_PI_D :: CDouble
sDL_PI_D = (CDouble
3.141592653589793 :: BG.CDouble)

-- | The value of Pi, as a single-precision floating point literal.
--
--     @since 3.2.0
--
--     [See also]: 'sDL_PI_D' pi (float)
--
--     [C declaration]: @macro SDL_PI_F@, defined at @SDL3\/SDL_stdinc.h 4492:9@
sDL_PI_F :: BG.CFloat
sDL_PI_F :: CFloat
sDL_PI_F = (CFloat
3.1415927 :: BG.CFloat)

-- | [C declaration]: @struct SDL_iconv_data_t@, defined at @SDL3\/SDL_stdinc.h 5815:16@
data SDL_iconv_data_t

-- | An opaque handle representing string encoding conversion state.
--
--     @since 3.2.0
--
--     [See also]: 'sDL_iconv_open'
--
--     [C declaration]: @SDL_iconv_t@, defined at @SDL3\/SDL_stdinc.h 5815:34@
newtype SDL_iconv_t = SDL_iconv_t
  { SDL_iconv_t -> Ptr SDL_iconv_data_t
unwrap :: BG.Ptr SDL_iconv_data_t
  }
  deriving stock ((forall x. SDL_iconv_t -> Rep SDL_iconv_t x)
-> (forall x. Rep SDL_iconv_t x -> SDL_iconv_t)
-> Generic SDL_iconv_t
forall x. Rep SDL_iconv_t x -> SDL_iconv_t
forall x. SDL_iconv_t -> Rep SDL_iconv_t x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_iconv_t -> Rep SDL_iconv_t x
from :: forall x. SDL_iconv_t -> Rep SDL_iconv_t x
$cto :: forall x. Rep SDL_iconv_t x -> SDL_iconv_t
to :: forall x. Rep SDL_iconv_t x -> SDL_iconv_t
BG.Generic, SDL_iconv_t -> SDL_iconv_t -> Bool
(SDL_iconv_t -> SDL_iconv_t -> Bool)
-> (SDL_iconv_t -> SDL_iconv_t -> Bool) -> Eq SDL_iconv_t
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SDL_iconv_t -> SDL_iconv_t -> Bool
== :: SDL_iconv_t -> SDL_iconv_t -> Bool
$c/= :: SDL_iconv_t -> SDL_iconv_t -> Bool
/= :: SDL_iconv_t -> SDL_iconv_t -> Bool
Eq, Eq SDL_iconv_t
Eq SDL_iconv_t =>
(SDL_iconv_t -> SDL_iconv_t -> Ordering)
-> (SDL_iconv_t -> SDL_iconv_t -> Bool)
-> (SDL_iconv_t -> SDL_iconv_t -> Bool)
-> (SDL_iconv_t -> SDL_iconv_t -> Bool)
-> (SDL_iconv_t -> SDL_iconv_t -> Bool)
-> (SDL_iconv_t -> SDL_iconv_t -> SDL_iconv_t)
-> (SDL_iconv_t -> SDL_iconv_t -> SDL_iconv_t)
-> Ord SDL_iconv_t
SDL_iconv_t -> SDL_iconv_t -> Bool
SDL_iconv_t -> SDL_iconv_t -> Ordering
SDL_iconv_t -> SDL_iconv_t -> SDL_iconv_t
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
$ccompare :: SDL_iconv_t -> SDL_iconv_t -> Ordering
compare :: SDL_iconv_t -> SDL_iconv_t -> Ordering
$c< :: SDL_iconv_t -> SDL_iconv_t -> Bool
< :: SDL_iconv_t -> SDL_iconv_t -> Bool
$c<= :: SDL_iconv_t -> SDL_iconv_t -> Bool
<= :: SDL_iconv_t -> SDL_iconv_t -> Bool
$c> :: SDL_iconv_t -> SDL_iconv_t -> Bool
> :: SDL_iconv_t -> SDL_iconv_t -> Bool
$c>= :: SDL_iconv_t -> SDL_iconv_t -> Bool
>= :: SDL_iconv_t -> SDL_iconv_t -> Bool
$cmax :: SDL_iconv_t -> SDL_iconv_t -> SDL_iconv_t
max :: SDL_iconv_t -> SDL_iconv_t -> SDL_iconv_t
$cmin :: SDL_iconv_t -> SDL_iconv_t -> SDL_iconv_t
min :: SDL_iconv_t -> SDL_iconv_t -> SDL_iconv_t
Ord, Int -> SDL_iconv_t -> ShowS
[SDL_iconv_t] -> ShowS
SDL_iconv_t -> String
(Int -> SDL_iconv_t -> ShowS)
-> (SDL_iconv_t -> String)
-> ([SDL_iconv_t] -> ShowS)
-> Show SDL_iconv_t
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SDL_iconv_t -> ShowS
showsPrec :: Int -> SDL_iconv_t -> ShowS
$cshow :: SDL_iconv_t -> String
show :: SDL_iconv_t -> String
$cshowList :: [SDL_iconv_t] -> ShowS
showList :: [SDL_iconv_t] -> ShowS
Show)
  deriving newtype
    ( FFIType SDL_iconv_t -> SDL_iconv_t
SDL_iconv_t -> FFIType SDL_iconv_t
(SDL_iconv_t -> FFIType SDL_iconv_t)
-> (FFIType SDL_iconv_t -> SDL_iconv_t) -> HasFFIType SDL_iconv_t
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: SDL_iconv_t -> FFIType SDL_iconv_t
toFFIType :: SDL_iconv_t -> FFIType SDL_iconv_t
$cfromFFIType :: FFIType SDL_iconv_t -> SDL_iconv_t
fromFFIType :: FFIType SDL_iconv_t -> SDL_iconv_t
BG.HasFFIType
    , Ptr SDL_iconv_t -> IO SDL_iconv_t
Ptr SDL_iconv_t -> Int -> IO SDL_iconv_t
Ptr SDL_iconv_t -> Int -> SDL_iconv_t -> IO ()
Ptr SDL_iconv_t -> SDL_iconv_t -> IO ()
SDL_iconv_t -> Int
(SDL_iconv_t -> Int)
-> (SDL_iconv_t -> Int)
-> (Ptr SDL_iconv_t -> Int -> IO SDL_iconv_t)
-> (Ptr SDL_iconv_t -> Int -> SDL_iconv_t -> IO ())
-> (forall b. Ptr b -> Int -> IO SDL_iconv_t)
-> (forall b. Ptr b -> Int -> SDL_iconv_t -> IO ())
-> (Ptr SDL_iconv_t -> IO SDL_iconv_t)
-> (Ptr SDL_iconv_t -> SDL_iconv_t -> IO ())
-> Storable SDL_iconv_t
forall b. Ptr b -> Int -> IO SDL_iconv_t
forall b. Ptr b -> Int -> SDL_iconv_t -> 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
$csizeOf :: SDL_iconv_t -> Int
sizeOf :: SDL_iconv_t -> Int
$calignment :: SDL_iconv_t -> Int
alignment :: SDL_iconv_t -> Int
$cpeekElemOff :: Ptr SDL_iconv_t -> Int -> IO SDL_iconv_t
peekElemOff :: Ptr SDL_iconv_t -> Int -> IO SDL_iconv_t
$cpokeElemOff :: Ptr SDL_iconv_t -> Int -> SDL_iconv_t -> IO ()
pokeElemOff :: Ptr SDL_iconv_t -> Int -> SDL_iconv_t -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO SDL_iconv_t
peekByteOff :: forall b. Ptr b -> Int -> IO SDL_iconv_t
$cpokeByteOff :: forall b. Ptr b -> Int -> SDL_iconv_t -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> SDL_iconv_t -> IO ()
$cpeek :: Ptr SDL_iconv_t -> IO SDL_iconv_t
peek :: Ptr SDL_iconv_t -> IO SDL_iconv_t
$cpoke :: Ptr SDL_iconv_t -> SDL_iconv_t -> IO ()
poke :: Ptr SDL_iconv_t -> SDL_iconv_t -> IO ()
BG.Storable
    , Ptr SDL_iconv_t -> IO SDL_iconv_t
(Ptr SDL_iconv_t -> IO SDL_iconv_t) -> ReadRaw SDL_iconv_t
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr SDL_iconv_t -> IO SDL_iconv_t
readRaw :: Ptr SDL_iconv_t -> IO SDL_iconv_t
Marshal.ReadRaw
    , Proxy SDL_iconv_t -> Int
(Proxy SDL_iconv_t -> Int)
-> (Proxy SDL_iconv_t -> Int) -> StaticSize SDL_iconv_t
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy SDL_iconv_t -> Int
staticSizeOf :: Proxy SDL_iconv_t -> Int
$cstaticAlignment :: Proxy SDL_iconv_t -> Int
staticAlignment :: Proxy SDL_iconv_t -> Int
Marshal.StaticSize
    , Ptr SDL_iconv_t -> SDL_iconv_t -> IO ()
(Ptr SDL_iconv_t -> SDL_iconv_t -> IO ()) -> WriteRaw SDL_iconv_t
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr SDL_iconv_t -> SDL_iconv_t -> IO ()
writeRaw :: Ptr SDL_iconv_t -> SDL_iconv_t -> IO ()
Marshal.WriteRaw
    )

instance
  (ty ~ BG.Ptr SDL_iconv_data_t)
  => BG.CompatHasField.HasField "unwrap" SDL_iconv_t ty
  where
  hasField :: SDL_iconv_t -> (ty -> SDL_iconv_t, ty)
hasField =
    \SDL_iconv_t
x0 ->
      ( \ty
y1 ->
          SDL_iconv_t{unwrap :: Ptr SDL_iconv_data_t
unwrap = ty
Ptr SDL_iconv_data_t
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_iconv_t
x0
      )

instance
  (ty ~ BG.Ptr SDL_iconv_data_t)
  => BG.HasField "unwrap" (BG.Ptr SDL_iconv_t) (BG.Ptr ty)
  where
  getField :: Ptr SDL_iconv_t -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_iconv_t -> Ptr (CFieldType SDL_iconv_t "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_iconv_t "unwrap" where
  type
    CFieldType SDL_iconv_t "unwrap" =
      BG.Ptr SDL_iconv_data_t

  offset# :: Proxy# SDL_iconv_t -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_iconv_t
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | Auxiliary type used by 'SDL_FunctionPointer'
--
--     [C declaration]: @SDL_FunctionPointer@, defined at @SDL3\/SDL_stdinc.h 6177:16@
newtype SDL_FunctionPointer_Aux = SDL_FunctionPointer_Aux
  { SDL_FunctionPointer_Aux -> IO ()
unwrap :: IO ()
  }
  deriving stock ((forall x.
 SDL_FunctionPointer_Aux -> Rep SDL_FunctionPointer_Aux x)
-> (forall x.
    Rep SDL_FunctionPointer_Aux x -> SDL_FunctionPointer_Aux)
-> Generic SDL_FunctionPointer_Aux
forall x. Rep SDL_FunctionPointer_Aux x -> SDL_FunctionPointer_Aux
forall x. SDL_FunctionPointer_Aux -> Rep SDL_FunctionPointer_Aux x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_FunctionPointer_Aux -> Rep SDL_FunctionPointer_Aux x
from :: forall x. SDL_FunctionPointer_Aux -> Rep SDL_FunctionPointer_Aux x
$cto :: forall x. Rep SDL_FunctionPointer_Aux x -> SDL_FunctionPointer_Aux
to :: forall x. Rep SDL_FunctionPointer_Aux x -> SDL_FunctionPointer_Aux
BG.Generic)

-- __unique:__ @toSDL_FunctionPointer_Aux@
foreign import ccall safe "wrapper"
  hs_bindgen_8e3379ae5ebc8b29_base
    :: IO ()
    -> IO (BG.FunPtr (IO ()))

-- __unique:__ @toSDL_FunctionPointer_Aux@
hs_bindgen_8e3379ae5ebc8b29
  :: SDL_FunctionPointer_Aux
  -> IO (BG.FunPtr SDL_FunctionPointer_Aux)
hs_bindgen_8e3379ae5ebc8b29 :: SDL_FunctionPointer_Aux -> IO (FunPtr SDL_FunctionPointer_Aux)
hs_bindgen_8e3379ae5ebc8b29 =
  \SDL_FunctionPointer_Aux
fun0 ->
    (FunPtr (IO ()) -> FunPtr SDL_FunctionPointer_Aux)
-> IO (FunPtr (IO ())) -> IO (FunPtr SDL_FunctionPointer_Aux)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap FunPtr (IO ()) -> FunPtr SDL_FunctionPointer_Aux
forall a b. FunPtr a -> FunPtr b
BG.castFunPtr (IO () -> IO (FunPtr (IO ()))
hs_bindgen_8e3379ae5ebc8b29_base (forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_FunctionPointer_Aux
fun0))

-- __unique:__ @fromSDL_FunctionPointer_Aux@
foreign import ccall safe "dynamic"
  hs_bindgen_8a4eac10e33e73be_base
    :: BG.FunPtr (IO ())
    -> IO ()

-- __unique:__ @fromSDL_FunctionPointer_Aux@
hs_bindgen_8a4eac10e33e73be
  :: BG.FunPtr SDL_FunctionPointer_Aux
  -> SDL_FunctionPointer_Aux
hs_bindgen_8a4eac10e33e73be :: FunPtr SDL_FunctionPointer_Aux -> SDL_FunctionPointer_Aux
hs_bindgen_8a4eac10e33e73be =
  \FunPtr SDL_FunctionPointer_Aux
funPtr0 ->
    IO () -> SDL_FunctionPointer_Aux
SDL_FunctionPointer_Aux (FunPtr (IO ()) -> IO ()
hs_bindgen_8a4eac10e33e73be_base (FunPtr SDL_FunctionPointer_Aux -> FunPtr (IO ())
forall a b. FunPtr a -> FunPtr b
BG.castFunPtr FunPtr SDL_FunctionPointer_Aux
funPtr0))

instance BG.ToFunPtr SDL_FunctionPointer_Aux where
  toFunPtr :: SDL_FunctionPointer_Aux -> IO (FunPtr SDL_FunctionPointer_Aux)
toFunPtr = SDL_FunctionPointer_Aux -> IO (FunPtr SDL_FunctionPointer_Aux)
hs_bindgen_8e3379ae5ebc8b29

instance BG.FromFunPtr SDL_FunctionPointer_Aux where
  fromFunPtr :: FunPtr SDL_FunctionPointer_Aux -> SDL_FunctionPointer_Aux
fromFunPtr = FunPtr SDL_FunctionPointer_Aux -> SDL_FunctionPointer_Aux
hs_bindgen_8a4eac10e33e73be

instance
  (ty ~ IO ())
  => BG.CompatHasField.HasField "unwrap" SDL_FunctionPointer_Aux ty
  where
  hasField :: SDL_FunctionPointer_Aux -> (ty -> SDL_FunctionPointer_Aux, ty)
hasField =
    \SDL_FunctionPointer_Aux
x0 ->
      ( \ty
y1 ->
          SDL_FunctionPointer_Aux{unwrap :: IO ()
unwrap = ty
IO ()
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_FunctionPointer_Aux
x0
      )

instance
  (ty ~ IO ())
  => BG.HasField "unwrap" (BG.Ptr SDL_FunctionPointer_Aux) (BG.Ptr ty)
  where
  getField :: Ptr SDL_FunctionPointer_Aux -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_FunctionPointer_Aux
-> Ptr (CFieldType SDL_FunctionPointer_Aux "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_FunctionPointer_Aux "unwrap" where
  type
    CFieldType SDL_FunctionPointer_Aux "unwrap" =
      IO ()

  offset# :: Proxy# SDL_FunctionPointer_Aux -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_FunctionPointer_Aux
_ -> \Proxy# "unwrap"
_ -> Int
0

-- | [C declaration]: @SDL_FunctionPointer@, defined at @SDL3\/SDL_stdinc.h 6177:16@
newtype SDL_FunctionPointer = SDL_FunctionPointer
  { SDL_FunctionPointer -> FunPtr SDL_FunctionPointer_Aux
unwrap :: BG.FunPtr SDL_FunctionPointer_Aux
  }
  deriving stock ((forall x. SDL_FunctionPointer -> Rep SDL_FunctionPointer x)
-> (forall x. Rep SDL_FunctionPointer x -> SDL_FunctionPointer)
-> Generic SDL_FunctionPointer
forall x. Rep SDL_FunctionPointer x -> SDL_FunctionPointer
forall x. SDL_FunctionPointer -> Rep SDL_FunctionPointer x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SDL_FunctionPointer -> Rep SDL_FunctionPointer x
from :: forall x. SDL_FunctionPointer -> Rep SDL_FunctionPointer x
$cto :: forall x. Rep SDL_FunctionPointer x -> SDL_FunctionPointer
to :: forall x. Rep SDL_FunctionPointer x -> SDL_FunctionPointer
BG.Generic, SDL_FunctionPointer -> SDL_FunctionPointer -> Bool
(SDL_FunctionPointer -> SDL_FunctionPointer -> Bool)
-> (SDL_FunctionPointer -> SDL_FunctionPointer -> Bool)
-> Eq SDL_FunctionPointer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SDL_FunctionPointer -> SDL_FunctionPointer -> Bool
== :: SDL_FunctionPointer -> SDL_FunctionPointer -> Bool
$c/= :: SDL_FunctionPointer -> SDL_FunctionPointer -> Bool
/= :: SDL_FunctionPointer -> SDL_FunctionPointer -> Bool
Eq, Eq SDL_FunctionPointer
Eq SDL_FunctionPointer =>
(SDL_FunctionPointer -> SDL_FunctionPointer -> Ordering)
-> (SDL_FunctionPointer -> SDL_FunctionPointer -> Bool)
-> (SDL_FunctionPointer -> SDL_FunctionPointer -> Bool)
-> (SDL_FunctionPointer -> SDL_FunctionPointer -> Bool)
-> (SDL_FunctionPointer -> SDL_FunctionPointer -> Bool)
-> (SDL_FunctionPointer
    -> SDL_FunctionPointer -> SDL_FunctionPointer)
-> (SDL_FunctionPointer
    -> SDL_FunctionPointer -> SDL_FunctionPointer)
-> Ord SDL_FunctionPointer
SDL_FunctionPointer -> SDL_FunctionPointer -> Bool
SDL_FunctionPointer -> SDL_FunctionPointer -> Ordering
SDL_FunctionPointer -> SDL_FunctionPointer -> SDL_FunctionPointer
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
$ccompare :: SDL_FunctionPointer -> SDL_FunctionPointer -> Ordering
compare :: SDL_FunctionPointer -> SDL_FunctionPointer -> Ordering
$c< :: SDL_FunctionPointer -> SDL_FunctionPointer -> Bool
< :: SDL_FunctionPointer -> SDL_FunctionPointer -> Bool
$c<= :: SDL_FunctionPointer -> SDL_FunctionPointer -> Bool
<= :: SDL_FunctionPointer -> SDL_FunctionPointer -> Bool
$c> :: SDL_FunctionPointer -> SDL_FunctionPointer -> Bool
> :: SDL_FunctionPointer -> SDL_FunctionPointer -> Bool
$c>= :: SDL_FunctionPointer -> SDL_FunctionPointer -> Bool
>= :: SDL_FunctionPointer -> SDL_FunctionPointer -> Bool
$cmax :: SDL_FunctionPointer -> SDL_FunctionPointer -> SDL_FunctionPointer
max :: SDL_FunctionPointer -> SDL_FunctionPointer -> SDL_FunctionPointer
$cmin :: SDL_FunctionPointer -> SDL_FunctionPointer -> SDL_FunctionPointer
min :: SDL_FunctionPointer -> SDL_FunctionPointer -> SDL_FunctionPointer
Ord, Int -> SDL_FunctionPointer -> ShowS
[SDL_FunctionPointer] -> ShowS
SDL_FunctionPointer -> String
(Int -> SDL_FunctionPointer -> ShowS)
-> (SDL_FunctionPointer -> String)
-> ([SDL_FunctionPointer] -> ShowS)
-> Show SDL_FunctionPointer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SDL_FunctionPointer -> ShowS
showsPrec :: Int -> SDL_FunctionPointer -> ShowS
$cshow :: SDL_FunctionPointer -> String
show :: SDL_FunctionPointer -> String
$cshowList :: [SDL_FunctionPointer] -> ShowS
showList :: [SDL_FunctionPointer] -> ShowS
Show)
  deriving newtype
    ( FFIType SDL_FunctionPointer -> SDL_FunctionPointer
SDL_FunctionPointer -> FFIType SDL_FunctionPointer
(SDL_FunctionPointer -> FFIType SDL_FunctionPointer)
-> (FFIType SDL_FunctionPointer -> SDL_FunctionPointer)
-> HasFFIType SDL_FunctionPointer
forall a. (a -> FFIType a) -> (FFIType a -> a) -> HasFFIType a
$ctoFFIType :: SDL_FunctionPointer -> FFIType SDL_FunctionPointer
toFFIType :: SDL_FunctionPointer -> FFIType SDL_FunctionPointer
$cfromFFIType :: FFIType SDL_FunctionPointer -> SDL_FunctionPointer
fromFFIType :: FFIType SDL_FunctionPointer -> SDL_FunctionPointer
BG.HasFFIType
    , Ptr SDL_FunctionPointer -> IO SDL_FunctionPointer
Ptr SDL_FunctionPointer -> Int -> IO SDL_FunctionPointer
Ptr SDL_FunctionPointer -> Int -> SDL_FunctionPointer -> IO ()
Ptr SDL_FunctionPointer -> SDL_FunctionPointer -> IO ()
SDL_FunctionPointer -> Int
(SDL_FunctionPointer -> Int)
-> (SDL_FunctionPointer -> Int)
-> (Ptr SDL_FunctionPointer -> Int -> IO SDL_FunctionPointer)
-> (Ptr SDL_FunctionPointer -> Int -> SDL_FunctionPointer -> IO ())
-> (forall b. Ptr b -> Int -> IO SDL_FunctionPointer)
-> (forall b. Ptr b -> Int -> SDL_FunctionPointer -> IO ())
-> (Ptr SDL_FunctionPointer -> IO SDL_FunctionPointer)
-> (Ptr SDL_FunctionPointer -> SDL_FunctionPointer -> IO ())
-> Storable SDL_FunctionPointer
forall b. Ptr b -> Int -> IO SDL_FunctionPointer
forall b. Ptr b -> Int -> SDL_FunctionPointer -> 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
$csizeOf :: SDL_FunctionPointer -> Int
sizeOf :: SDL_FunctionPointer -> Int
$calignment :: SDL_FunctionPointer -> Int
alignment :: SDL_FunctionPointer -> Int
$cpeekElemOff :: Ptr SDL_FunctionPointer -> Int -> IO SDL_FunctionPointer
peekElemOff :: Ptr SDL_FunctionPointer -> Int -> IO SDL_FunctionPointer
$cpokeElemOff :: Ptr SDL_FunctionPointer -> Int -> SDL_FunctionPointer -> IO ()
pokeElemOff :: Ptr SDL_FunctionPointer -> Int -> SDL_FunctionPointer -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO SDL_FunctionPointer
peekByteOff :: forall b. Ptr b -> Int -> IO SDL_FunctionPointer
$cpokeByteOff :: forall b. Ptr b -> Int -> SDL_FunctionPointer -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> SDL_FunctionPointer -> IO ()
$cpeek :: Ptr SDL_FunctionPointer -> IO SDL_FunctionPointer
peek :: Ptr SDL_FunctionPointer -> IO SDL_FunctionPointer
$cpoke :: Ptr SDL_FunctionPointer -> SDL_FunctionPointer -> IO ()
poke :: Ptr SDL_FunctionPointer -> SDL_FunctionPointer -> IO ()
BG.Storable
    , Ptr SDL_FunctionPointer -> IO SDL_FunctionPointer
(Ptr SDL_FunctionPointer -> IO SDL_FunctionPointer)
-> ReadRaw SDL_FunctionPointer
forall a. (Ptr a -> IO a) -> ReadRaw a
$creadRaw :: Ptr SDL_FunctionPointer -> IO SDL_FunctionPointer
readRaw :: Ptr SDL_FunctionPointer -> IO SDL_FunctionPointer
Marshal.ReadRaw
    , Proxy SDL_FunctionPointer -> Int
(Proxy SDL_FunctionPointer -> Int)
-> (Proxy SDL_FunctionPointer -> Int)
-> StaticSize SDL_FunctionPointer
forall a. (Proxy a -> Int) -> (Proxy a -> Int) -> StaticSize a
$cstaticSizeOf :: Proxy SDL_FunctionPointer -> Int
staticSizeOf :: Proxy SDL_FunctionPointer -> Int
$cstaticAlignment :: Proxy SDL_FunctionPointer -> Int
staticAlignment :: Proxy SDL_FunctionPointer -> Int
Marshal.StaticSize
    , Ptr SDL_FunctionPointer -> SDL_FunctionPointer -> IO ()
(Ptr SDL_FunctionPointer -> SDL_FunctionPointer -> IO ())
-> WriteRaw SDL_FunctionPointer
forall a. (Ptr a -> a -> IO ()) -> WriteRaw a
$cwriteRaw :: Ptr SDL_FunctionPointer -> SDL_FunctionPointer -> IO ()
writeRaw :: Ptr SDL_FunctionPointer -> SDL_FunctionPointer -> IO ()
Marshal.WriteRaw
    )

instance
  (ty ~ BG.FunPtr SDL_FunctionPointer_Aux)
  => BG.CompatHasField.HasField "unwrap" SDL_FunctionPointer ty
  where
  hasField :: SDL_FunctionPointer -> (ty -> SDL_FunctionPointer, ty)
hasField =
    \SDL_FunctionPointer
x0 ->
      ( \ty
y1 ->
          SDL_FunctionPointer{unwrap :: FunPtr SDL_FunctionPointer_Aux
unwrap = ty
FunPtr SDL_FunctionPointer_Aux
y1}
      , forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
BG.getField @"unwrap" SDL_FunctionPointer
x0
      )

instance
  (ty ~ BG.FunPtr SDL_FunctionPointer_Aux)
  => BG.HasField "unwrap" (BG.Ptr SDL_FunctionPointer) (BG.Ptr ty)
  where
  getField :: Ptr SDL_FunctionPointer -> Ptr ty
getField = Proxy "unwrap"
-> Ptr SDL_FunctionPointer
-> Ptr (CFieldType SDL_FunctionPointer "unwrap")
forall a (field :: Symbol).
HasCField a field =>
Proxy field -> Ptr a -> Ptr (CFieldType a field)
HasCField.fromPtr (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
BG.Proxy @"unwrap")

instance HasCField.HasCField SDL_FunctionPointer "unwrap" where
  type
    CFieldType SDL_FunctionPointer "unwrap" =
      BG.FunPtr SDL_FunctionPointer_Aux

  offset# :: Proxy# SDL_FunctionPointer -> Proxy# "unwrap" -> Int
offset# = \Proxy# SDL_FunctionPointer
_ -> \Proxy# "unwrap"
_ -> Int
0