hs-bindgen-1.0.0.0: test-artefacts/fixtures/binding-specs/stdlib/instances.1.c23-parse-all/Example.hs

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE UndecidableInstances #-}

module Example
    ( Example.Stdlib_CBool(..)
    , Example.Stdlib_Int8(..)
    , Example.Stdlib_Int16(..)
    , Example.Stdlib_Int32(..)
    , Example.Stdlib_Int64(..)
    , Example.Stdlib_Word8(..)
    , Example.Stdlib_Word16(..)
    , Example.Stdlib_Word32(..)
    , Example.Stdlib_Word64(..)
    , Example.Stdlib_CIntMax(..)
    , Example.Stdlib_CUIntMax(..)
    , Example.Stdlib_CIntPtr(..)
    , Example.Stdlib_CUIntPtr(..)
    , Example.Stdlib_CFenvT(..)
    , Example.Stdlib_CFexceptT(..)
    , Example.Stdlib_CSize(..)
    , Example.Stdlib_CPtrdiff(..)
    , Example.Stdlib_CJmpBuf(..)
    , Example.Stdlib_CWchar(..)
    , Example.Stdlib_CWintT(..)
    , Example.Stdlib_CMbstateT(..)
    , Example.Stdlib_CWctransT(..)
    , Example.Stdlib_CWctypeT(..)
    , Example.Stdlib_CChar16T(..)
    , Example.Stdlib_CChar32T(..)
    , Example.Stdlib_CTime(..)
    , Example.Stdlib_CClock(..)
    , Example.Stdlib_CTm(..)
    , Example.Stdlib_CFile(..)
    , Example.Stdlib_CFpos(..)
    , Example.Stdlib_CSigAtomic(..)
    )
  where

import qualified HsBindgen.Runtime.HasCField as HasCField
import qualified HsBindgen.Runtime.LibC
import qualified HsBindgen.Runtime.Marshal as Marshal
import qualified HsBindgen.Runtime.Support as BG
import qualified HsBindgen.Runtime.Support.CompatHasField as BG.CompatHasField
import Prelude (Bounded, Enum, Eq, Integral, Num, Ord, Read, Real, Show, type (~))

{-| __C declaration:__ @stdlib_CBool@

    __defined at:__ @binding-specs\/stdlib\/instances.h 18:14@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CBool = Stdlib_CBool
  { unwrapStdlib_CBool :: BG.CBool
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ BG.CBool
         ) => BG.CompatHasField.HasField "unwrapStdlib_CBool" Stdlib_CBool ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CBool {unwrapStdlib_CBool = y1}
      , BG.getField @"unwrapStdlib_CBool" x0
      )

instance ( ty ~ BG.CBool
         ) => BG.HasField "unwrapStdlib_CBool" (BG.Ptr Stdlib_CBool) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CBool")

instance HasCField.HasCField Stdlib_CBool "unwrapStdlib_CBool" where

  type CFieldType Stdlib_CBool "unwrapStdlib_CBool" =
    BG.CBool

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_Int8@

    __defined at:__ @binding-specs\/stdlib\/instances.h 21:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_Int8 = Stdlib_Int8
  { unwrapStdlib_Int8 :: HsBindgen.Runtime.LibC.Int8
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.Int8
         ) => BG.CompatHasField.HasField "unwrapStdlib_Int8" Stdlib_Int8 ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_Int8 {unwrapStdlib_Int8 = y1}
      , BG.getField @"unwrapStdlib_Int8" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Int8
         ) => BG.HasField "unwrapStdlib_Int8" (BG.Ptr Stdlib_Int8) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_Int8")

instance HasCField.HasCField Stdlib_Int8 "unwrapStdlib_Int8" where

  type CFieldType Stdlib_Int8 "unwrapStdlib_Int8" =
    HsBindgen.Runtime.LibC.Int8

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_Int16@

    __defined at:__ @binding-specs\/stdlib\/instances.h 22:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_Int16 = Stdlib_Int16
  { unwrapStdlib_Int16 :: HsBindgen.Runtime.LibC.Int16
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.Int16
         ) => BG.CompatHasField.HasField "unwrapStdlib_Int16" Stdlib_Int16 ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_Int16 {unwrapStdlib_Int16 = y1}
      , BG.getField @"unwrapStdlib_Int16" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Int16
         ) => BG.HasField "unwrapStdlib_Int16" (BG.Ptr Stdlib_Int16) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_Int16")

instance HasCField.HasCField Stdlib_Int16 "unwrapStdlib_Int16" where

  type CFieldType Stdlib_Int16 "unwrapStdlib_Int16" =
    HsBindgen.Runtime.LibC.Int16

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_Int32@

    __defined at:__ @binding-specs\/stdlib\/instances.h 23:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_Int32 = Stdlib_Int32
  { unwrapStdlib_Int32 :: HsBindgen.Runtime.LibC.Int32
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.Int32
         ) => BG.CompatHasField.HasField "unwrapStdlib_Int32" Stdlib_Int32 ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_Int32 {unwrapStdlib_Int32 = y1}
      , BG.getField @"unwrapStdlib_Int32" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Int32
         ) => BG.HasField "unwrapStdlib_Int32" (BG.Ptr Stdlib_Int32) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_Int32")

instance HasCField.HasCField Stdlib_Int32 "unwrapStdlib_Int32" where

  type CFieldType Stdlib_Int32 "unwrapStdlib_Int32" =
    HsBindgen.Runtime.LibC.Int32

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_Int64@

    __defined at:__ @binding-specs\/stdlib\/instances.h 24:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_Int64 = Stdlib_Int64
  { unwrapStdlib_Int64 :: HsBindgen.Runtime.LibC.Int64
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.Int64
         ) => BG.CompatHasField.HasField "unwrapStdlib_Int64" Stdlib_Int64 ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_Int64 {unwrapStdlib_Int64 = y1}
      , BG.getField @"unwrapStdlib_Int64" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Int64
         ) => BG.HasField "unwrapStdlib_Int64" (BG.Ptr Stdlib_Int64) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_Int64")

instance HasCField.HasCField Stdlib_Int64 "unwrapStdlib_Int64" where

  type CFieldType Stdlib_Int64 "unwrapStdlib_Int64" =
    HsBindgen.Runtime.LibC.Int64

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_Word8@

    __defined at:__ @binding-specs\/stdlib\/instances.h 25:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_Word8 = Stdlib_Word8
  { unwrapStdlib_Word8 :: HsBindgen.Runtime.LibC.Word8
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.CompatHasField.HasField "unwrapStdlib_Word8" Stdlib_Word8 ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_Word8 {unwrapStdlib_Word8 = y1}
      , BG.getField @"unwrapStdlib_Word8" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word8
         ) => BG.HasField "unwrapStdlib_Word8" (BG.Ptr Stdlib_Word8) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_Word8")

instance HasCField.HasCField Stdlib_Word8 "unwrapStdlib_Word8" where

  type CFieldType Stdlib_Word8 "unwrapStdlib_Word8" =
    HsBindgen.Runtime.LibC.Word8

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_Word16@

    __defined at:__ @binding-specs\/stdlib\/instances.h 26:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_Word16 = Stdlib_Word16
  { unwrapStdlib_Word16 :: HsBindgen.Runtime.LibC.Word16
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.CompatHasField.HasField "unwrapStdlib_Word16" Stdlib_Word16 ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_Word16 {unwrapStdlib_Word16 = y1}
      , BG.getField @"unwrapStdlib_Word16" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word16
         ) => BG.HasField "unwrapStdlib_Word16" (BG.Ptr Stdlib_Word16) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_Word16")

instance HasCField.HasCField Stdlib_Word16 "unwrapStdlib_Word16" where

  type CFieldType Stdlib_Word16 "unwrapStdlib_Word16" =
    HsBindgen.Runtime.LibC.Word16

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_Word32@

    __defined at:__ @binding-specs\/stdlib\/instances.h 27:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_Word32 = Stdlib_Word32
  { unwrapStdlib_Word32 :: HsBindgen.Runtime.LibC.Word32
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.CompatHasField.HasField "unwrapStdlib_Word32" Stdlib_Word32 ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_Word32 {unwrapStdlib_Word32 = y1}
      , BG.getField @"unwrapStdlib_Word32" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word32
         ) => BG.HasField "unwrapStdlib_Word32" (BG.Ptr Stdlib_Word32) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_Word32")

instance HasCField.HasCField Stdlib_Word32 "unwrapStdlib_Word32" where

  type CFieldType Stdlib_Word32 "unwrapStdlib_Word32" =
    HsBindgen.Runtime.LibC.Word32

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_Word64@

    __defined at:__ @binding-specs\/stdlib\/instances.h 28:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_Word64 = Stdlib_Word64
  { unwrapStdlib_Word64 :: HsBindgen.Runtime.LibC.Word64
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.Word64
         ) => BG.CompatHasField.HasField "unwrapStdlib_Word64" Stdlib_Word64 ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_Word64 {unwrapStdlib_Word64 = y1}
      , BG.getField @"unwrapStdlib_Word64" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.Word64
         ) => BG.HasField "unwrapStdlib_Word64" (BG.Ptr Stdlib_Word64) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_Word64")

instance HasCField.HasCField Stdlib_Word64 "unwrapStdlib_Word64" where

  type CFieldType Stdlib_Word64 "unwrapStdlib_Word64" =
    HsBindgen.Runtime.LibC.Word64

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CIntMax@

    __defined at:__ @binding-specs\/stdlib\/instances.h 29:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CIntMax = Stdlib_CIntMax
  { unwrapStdlib_CIntMax :: HsBindgen.Runtime.LibC.CIntMax
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CIntMax
         ) => BG.CompatHasField.HasField "unwrapStdlib_CIntMax" Stdlib_CIntMax ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CIntMax {unwrapStdlib_CIntMax = y1}
      , BG.getField @"unwrapStdlib_CIntMax" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CIntMax
         ) => BG.HasField "unwrapStdlib_CIntMax" (BG.Ptr Stdlib_CIntMax) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CIntMax")

instance HasCField.HasCField Stdlib_CIntMax "unwrapStdlib_CIntMax" where

  type CFieldType Stdlib_CIntMax "unwrapStdlib_CIntMax" =
    HsBindgen.Runtime.LibC.CIntMax

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CUIntMax@

    __defined at:__ @binding-specs\/stdlib\/instances.h 30:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CUIntMax = Stdlib_CUIntMax
  { unwrapStdlib_CUIntMax :: HsBindgen.Runtime.LibC.CUIntMax
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CUIntMax
         ) => BG.CompatHasField.HasField "unwrapStdlib_CUIntMax" Stdlib_CUIntMax ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CUIntMax {unwrapStdlib_CUIntMax = y1}
      , BG.getField @"unwrapStdlib_CUIntMax" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CUIntMax
         ) => BG.HasField "unwrapStdlib_CUIntMax" (BG.Ptr Stdlib_CUIntMax) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CUIntMax")

instance HasCField.HasCField Stdlib_CUIntMax "unwrapStdlib_CUIntMax" where

  type CFieldType Stdlib_CUIntMax "unwrapStdlib_CUIntMax" =
    HsBindgen.Runtime.LibC.CUIntMax

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CIntPtr@

    __defined at:__ @binding-specs\/stdlib\/instances.h 31:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CIntPtr = Stdlib_CIntPtr
  { unwrapStdlib_CIntPtr :: HsBindgen.Runtime.LibC.CIntPtr
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CIntPtr
         ) => BG.CompatHasField.HasField "unwrapStdlib_CIntPtr" Stdlib_CIntPtr ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CIntPtr {unwrapStdlib_CIntPtr = y1}
      , BG.getField @"unwrapStdlib_CIntPtr" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CIntPtr
         ) => BG.HasField "unwrapStdlib_CIntPtr" (BG.Ptr Stdlib_CIntPtr) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CIntPtr")

instance HasCField.HasCField Stdlib_CIntPtr "unwrapStdlib_CIntPtr" where

  type CFieldType Stdlib_CIntPtr "unwrapStdlib_CIntPtr" =
    HsBindgen.Runtime.LibC.CIntPtr

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CUIntPtr@

    __defined at:__ @binding-specs\/stdlib\/instances.h 32:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CUIntPtr = Stdlib_CUIntPtr
  { unwrapStdlib_CUIntPtr :: HsBindgen.Runtime.LibC.CUIntPtr
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CUIntPtr
         ) => BG.CompatHasField.HasField "unwrapStdlib_CUIntPtr" Stdlib_CUIntPtr ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CUIntPtr {unwrapStdlib_CUIntPtr = y1}
      , BG.getField @"unwrapStdlib_CUIntPtr" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CUIntPtr
         ) => BG.HasField "unwrapStdlib_CUIntPtr" (BG.Ptr Stdlib_CUIntPtr) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CUIntPtr")

instance HasCField.HasCField Stdlib_CUIntPtr "unwrapStdlib_CUIntPtr" where

  type CFieldType Stdlib_CUIntPtr "unwrapStdlib_CUIntPtr" =
    HsBindgen.Runtime.LibC.CUIntPtr

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CFenvT@

    __defined at:__ @binding-specs\/stdlib\/instances.h 35:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CFenvT = Stdlib_CFenvT
  { unwrapStdlib_CFenvT :: HsBindgen.Runtime.LibC.CFenvT
  }
  deriving stock (BG.Generic)

instance ( ty ~ HsBindgen.Runtime.LibC.CFenvT
         ) => BG.CompatHasField.HasField "unwrapStdlib_CFenvT" Stdlib_CFenvT ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CFenvT {unwrapStdlib_CFenvT = y1}
      , BG.getField @"unwrapStdlib_CFenvT" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CFenvT
         ) => BG.HasField "unwrapStdlib_CFenvT" (BG.Ptr Stdlib_CFenvT) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CFenvT")

instance HasCField.HasCField Stdlib_CFenvT "unwrapStdlib_CFenvT" where

  type CFieldType Stdlib_CFenvT "unwrapStdlib_CFenvT" =
    HsBindgen.Runtime.LibC.CFenvT

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CFexceptT@

    __defined at:__ @binding-specs\/stdlib\/instances.h 36:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CFexceptT = Stdlib_CFexceptT
  { unwrapStdlib_CFexceptT :: HsBindgen.Runtime.LibC.CFexceptT
  }
  deriving stock (BG.Generic)

instance ( ty ~ HsBindgen.Runtime.LibC.CFexceptT
         ) => BG.CompatHasField.HasField "unwrapStdlib_CFexceptT" Stdlib_CFexceptT ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Stdlib_CFexceptT {unwrapStdlib_CFexceptT = y1}
      , BG.getField @"unwrapStdlib_CFexceptT" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CFexceptT
         ) => BG.HasField "unwrapStdlib_CFexceptT" (BG.Ptr Stdlib_CFexceptT) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CFexceptT")

instance HasCField.HasCField Stdlib_CFexceptT "unwrapStdlib_CFexceptT" where

  type CFieldType Stdlib_CFexceptT "unwrapStdlib_CFexceptT" =
    HsBindgen.Runtime.LibC.CFexceptT

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CSize@

    __defined at:__ @binding-specs\/stdlib\/instances.h 39:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CSize = Stdlib_CSize
  { unwrapStdlib_CSize :: HsBindgen.Runtime.LibC.CSize
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CSize
         ) => BG.CompatHasField.HasField "unwrapStdlib_CSize" Stdlib_CSize ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CSize {unwrapStdlib_CSize = y1}
      , BG.getField @"unwrapStdlib_CSize" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CSize
         ) => BG.HasField "unwrapStdlib_CSize" (BG.Ptr Stdlib_CSize) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CSize")

instance HasCField.HasCField Stdlib_CSize "unwrapStdlib_CSize" where

  type CFieldType Stdlib_CSize "unwrapStdlib_CSize" =
    HsBindgen.Runtime.LibC.CSize

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CPtrdiff@

    __defined at:__ @binding-specs\/stdlib\/instances.h 40:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CPtrdiff = Stdlib_CPtrdiff
  { unwrapStdlib_CPtrdiff :: HsBindgen.Runtime.LibC.CPtrdiff
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CPtrdiff
         ) => BG.CompatHasField.HasField "unwrapStdlib_CPtrdiff" Stdlib_CPtrdiff ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CPtrdiff {unwrapStdlib_CPtrdiff = y1}
      , BG.getField @"unwrapStdlib_CPtrdiff" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CPtrdiff
         ) => BG.HasField "unwrapStdlib_CPtrdiff" (BG.Ptr Stdlib_CPtrdiff) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CPtrdiff")

instance HasCField.HasCField Stdlib_CPtrdiff "unwrapStdlib_CPtrdiff" where

  type CFieldType Stdlib_CPtrdiff "unwrapStdlib_CPtrdiff" =
    HsBindgen.Runtime.LibC.CPtrdiff

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CJmpBuf@

    __defined at:__ @binding-specs\/stdlib\/instances.h 43:17@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CJmpBuf = Stdlib_CJmpBuf
  { unwrapStdlib_CJmpBuf :: HsBindgen.Runtime.LibC.CJmpBuf
  }
  deriving stock (BG.Generic)

instance ( ty ~ HsBindgen.Runtime.LibC.CJmpBuf
         ) => BG.CompatHasField.HasField "unwrapStdlib_CJmpBuf" Stdlib_CJmpBuf ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CJmpBuf {unwrapStdlib_CJmpBuf = y1}
      , BG.getField @"unwrapStdlib_CJmpBuf" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CJmpBuf
         ) => BG.HasField "unwrapStdlib_CJmpBuf" (BG.Ptr Stdlib_CJmpBuf) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CJmpBuf")

instance HasCField.HasCField Stdlib_CJmpBuf "unwrapStdlib_CJmpBuf" where

  type CFieldType Stdlib_CJmpBuf "unwrapStdlib_CJmpBuf" =
    HsBindgen.Runtime.LibC.CJmpBuf

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CWchar@

    __defined at:__ @binding-specs\/stdlib\/instances.h 46:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CWchar = Stdlib_CWchar
  { unwrapStdlib_CWchar :: HsBindgen.Runtime.LibC.CWchar
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CWchar
         ) => BG.CompatHasField.HasField "unwrapStdlib_CWchar" Stdlib_CWchar ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CWchar {unwrapStdlib_CWchar = y1}
      , BG.getField @"unwrapStdlib_CWchar" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CWchar
         ) => BG.HasField "unwrapStdlib_CWchar" (BG.Ptr Stdlib_CWchar) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CWchar")

instance HasCField.HasCField Stdlib_CWchar "unwrapStdlib_CWchar" where

  type CFieldType Stdlib_CWchar "unwrapStdlib_CWchar" =
    HsBindgen.Runtime.LibC.CWchar

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CWintT@

    __defined at:__ @binding-specs\/stdlib\/instances.h 47:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CWintT = Stdlib_CWintT
  { unwrapStdlib_CWintT :: HsBindgen.Runtime.LibC.CWintT
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CWintT
         ) => BG.CompatHasField.HasField "unwrapStdlib_CWintT" Stdlib_CWintT ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CWintT {unwrapStdlib_CWintT = y1}
      , BG.getField @"unwrapStdlib_CWintT" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CWintT
         ) => BG.HasField "unwrapStdlib_CWintT" (BG.Ptr Stdlib_CWintT) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CWintT")

instance HasCField.HasCField Stdlib_CWintT "unwrapStdlib_CWintT" where

  type CFieldType Stdlib_CWintT "unwrapStdlib_CWintT" =
    HsBindgen.Runtime.LibC.CWintT

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CMbstateT@

    __defined at:__ @binding-specs\/stdlib\/instances.h 48:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CMbstateT = Stdlib_CMbstateT
  { unwrapStdlib_CMbstateT :: HsBindgen.Runtime.LibC.CMbstateT
  }
  deriving stock (BG.Generic)

instance ( ty ~ HsBindgen.Runtime.LibC.CMbstateT
         ) => BG.CompatHasField.HasField "unwrapStdlib_CMbstateT" Stdlib_CMbstateT ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Stdlib_CMbstateT {unwrapStdlib_CMbstateT = y1}
      , BG.getField @"unwrapStdlib_CMbstateT" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CMbstateT
         ) => BG.HasField "unwrapStdlib_CMbstateT" (BG.Ptr Stdlib_CMbstateT) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CMbstateT")

instance HasCField.HasCField Stdlib_CMbstateT "unwrapStdlib_CMbstateT" where

  type CFieldType Stdlib_CMbstateT "unwrapStdlib_CMbstateT" =
    HsBindgen.Runtime.LibC.CMbstateT

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CWctransT@

    __defined at:__ @binding-specs\/stdlib\/instances.h 49:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CWctransT = Stdlib_CWctransT
  { unwrapStdlib_CWctransT :: HsBindgen.Runtime.LibC.CWctransT
  }
  deriving stock (Eq, BG.Generic, Show)
  deriving newtype
    ( BG.HasFFIType
    , BG.Prim
    , Marshal.ReadRaw
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CWctransT
         ) => BG.CompatHasField.HasField "unwrapStdlib_CWctransT" Stdlib_CWctransT ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Stdlib_CWctransT {unwrapStdlib_CWctransT = y1}
      , BG.getField @"unwrapStdlib_CWctransT" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CWctransT
         ) => BG.HasField "unwrapStdlib_CWctransT" (BG.Ptr Stdlib_CWctransT) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CWctransT")

instance HasCField.HasCField Stdlib_CWctransT "unwrapStdlib_CWctransT" where

  type CFieldType Stdlib_CWctransT "unwrapStdlib_CWctransT" =
    HsBindgen.Runtime.LibC.CWctransT

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CWctypeT@

    __defined at:__ @binding-specs\/stdlib\/instances.h 50:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CWctypeT = Stdlib_CWctypeT
  { unwrapStdlib_CWctypeT :: HsBindgen.Runtime.LibC.CWctypeT
  }
  deriving stock (Eq, BG.Generic, Show)
  deriving newtype
    ( BG.HasFFIType
    , BG.Prim
    , Marshal.ReadRaw
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CWctypeT
         ) => BG.CompatHasField.HasField "unwrapStdlib_CWctypeT" Stdlib_CWctypeT ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CWctypeT {unwrapStdlib_CWctypeT = y1}
      , BG.getField @"unwrapStdlib_CWctypeT" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CWctypeT
         ) => BG.HasField "unwrapStdlib_CWctypeT" (BG.Ptr Stdlib_CWctypeT) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CWctypeT")

instance HasCField.HasCField Stdlib_CWctypeT "unwrapStdlib_CWctypeT" where

  type CFieldType Stdlib_CWctypeT "unwrapStdlib_CWctypeT" =
    HsBindgen.Runtime.LibC.CWctypeT

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CChar16T@

    __defined at:__ @binding-specs\/stdlib\/instances.h 51:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CChar16T = Stdlib_CChar16T
  { unwrapStdlib_CChar16T :: HsBindgen.Runtime.LibC.CChar16T
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CChar16T
         ) => BG.CompatHasField.HasField "unwrapStdlib_CChar16T" Stdlib_CChar16T ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CChar16T {unwrapStdlib_CChar16T = y1}
      , BG.getField @"unwrapStdlib_CChar16T" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CChar16T
         ) => BG.HasField "unwrapStdlib_CChar16T" (BG.Ptr Stdlib_CChar16T) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CChar16T")

instance HasCField.HasCField Stdlib_CChar16T "unwrapStdlib_CChar16T" where

  type CFieldType Stdlib_CChar16T "unwrapStdlib_CChar16T" =
    HsBindgen.Runtime.LibC.CChar16T

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CChar32T@

    __defined at:__ @binding-specs\/stdlib\/instances.h 52:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CChar32T = Stdlib_CChar32T
  { unwrapStdlib_CChar32T :: HsBindgen.Runtime.LibC.CChar32T
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CChar32T
         ) => BG.CompatHasField.HasField "unwrapStdlib_CChar32T" Stdlib_CChar32T ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CChar32T {unwrapStdlib_CChar32T = y1}
      , BG.getField @"unwrapStdlib_CChar32T" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CChar32T
         ) => BG.HasField "unwrapStdlib_CChar32T" (BG.Ptr Stdlib_CChar32T) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CChar32T")

instance HasCField.HasCField Stdlib_CChar32T "unwrapStdlib_CChar32T" where

  type CFieldType Stdlib_CChar32T "unwrapStdlib_CChar32T" =
    HsBindgen.Runtime.LibC.CChar32T

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CTime@

    __defined at:__ @binding-specs\/stdlib\/instances.h 55:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CTime = Stdlib_CTime
  { unwrapStdlib_CTime :: HsBindgen.Runtime.LibC.CTime
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( Enum
    , BG.HasFFIType
    , Num
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CTime
         ) => BG.CompatHasField.HasField "unwrapStdlib_CTime" Stdlib_CTime ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CTime {unwrapStdlib_CTime = y1}
      , BG.getField @"unwrapStdlib_CTime" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CTime
         ) => BG.HasField "unwrapStdlib_CTime" (BG.Ptr Stdlib_CTime) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CTime")

instance HasCField.HasCField Stdlib_CTime "unwrapStdlib_CTime" where

  type CFieldType Stdlib_CTime "unwrapStdlib_CTime" =
    HsBindgen.Runtime.LibC.CTime

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CClock@

    __defined at:__ @binding-specs\/stdlib\/instances.h 56:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CClock = Stdlib_CClock
  { unwrapStdlib_CClock :: HsBindgen.Runtime.LibC.CClock
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( Enum
    , BG.HasFFIType
    , Num
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CClock
         ) => BG.CompatHasField.HasField "unwrapStdlib_CClock" Stdlib_CClock ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CClock {unwrapStdlib_CClock = y1}
      , BG.getField @"unwrapStdlib_CClock" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CClock
         ) => BG.HasField "unwrapStdlib_CClock" (BG.Ptr Stdlib_CClock) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CClock")

instance HasCField.HasCField Stdlib_CClock "unwrapStdlib_CClock" where

  type CFieldType Stdlib_CClock "unwrapStdlib_CClock" =
    HsBindgen.Runtime.LibC.CClock

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CTm@

    __defined at:__ @binding-specs\/stdlib\/instances.h 57:19@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CTm = Stdlib_CTm
  { unwrapStdlib_CTm :: HsBindgen.Runtime.LibC.CTm
  }
  deriving stock (Eq, BG.Generic, Show)
  deriving newtype (Marshal.ReadRaw, Marshal.StaticSize)

instance ( ty ~ HsBindgen.Runtime.LibC.CTm
         ) => BG.CompatHasField.HasField "unwrapStdlib_CTm" Stdlib_CTm ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CTm {unwrapStdlib_CTm = y1}
      , BG.getField @"unwrapStdlib_CTm" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CTm
         ) => BG.HasField "unwrapStdlib_CTm" (BG.Ptr Stdlib_CTm) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CTm")

instance HasCField.HasCField Stdlib_CTm "unwrapStdlib_CTm" where

  type CFieldType Stdlib_CTm "unwrapStdlib_CTm" =
    HsBindgen.Runtime.LibC.CTm

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CFile@

    __defined at:__ @binding-specs\/stdlib\/instances.h 60:16@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CFile = Stdlib_CFile
  { unwrapStdlib_CFile :: HsBindgen.Runtime.LibC.CFile
  }
  deriving stock (BG.Generic)

instance ( ty ~ HsBindgen.Runtime.LibC.CFile
         ) => BG.CompatHasField.HasField "unwrapStdlib_CFile" Stdlib_CFile ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CFile {unwrapStdlib_CFile = y1}
      , BG.getField @"unwrapStdlib_CFile" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CFile
         ) => BG.HasField "unwrapStdlib_CFile" (BG.Ptr Stdlib_CFile) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CFile")

instance HasCField.HasCField Stdlib_CFile "unwrapStdlib_CFile" where

  type CFieldType Stdlib_CFile "unwrapStdlib_CFile" =
    HsBindgen.Runtime.LibC.CFile

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CFpos@

    __defined at:__ @binding-specs\/stdlib\/instances.h 61:16@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CFpos = Stdlib_CFpos
  { unwrapStdlib_CFpos :: HsBindgen.Runtime.LibC.CFpos
  }
  deriving stock (BG.Generic)

instance ( ty ~ HsBindgen.Runtime.LibC.CFpos
         ) => BG.CompatHasField.HasField "unwrapStdlib_CFpos" Stdlib_CFpos ty where

  hasField =
    \x0 ->
      ( \y1 -> Stdlib_CFpos {unwrapStdlib_CFpos = y1}
      , BG.getField @"unwrapStdlib_CFpos" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CFpos
         ) => BG.HasField "unwrapStdlib_CFpos" (BG.Ptr Stdlib_CFpos) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CFpos")

instance HasCField.HasCField Stdlib_CFpos "unwrapStdlib_CFpos" where

  type CFieldType Stdlib_CFpos "unwrapStdlib_CFpos" =
    HsBindgen.Runtime.LibC.CFpos

  offset# = \_ -> \_ -> 0

{-| __C declaration:__ @stdlib_CSigAtomic@

    __defined at:__ @binding-specs\/stdlib\/instances.h 64:22@

    __exported by:__ @binding-specs\/stdlib\/instances.h@
-}
newtype Stdlib_CSigAtomic = Stdlib_CSigAtomic
  { unwrapStdlib_CSigAtomic :: HsBindgen.Runtime.LibC.CSigAtomic
  }
  deriving stock (Eq, BG.Generic, Ord, Read, Show)
  deriving newtype
    ( BG.Bitfield
    , BG.Bits
    , Bounded
    , Enum
    , BG.FiniteBits
    , BG.HasFFIType
    , Integral
    , BG.Ix
    , Num
    , BG.Prim
    , Marshal.ReadRaw
    , Real
    , Marshal.StaticSize
    , BG.Storable
    , Marshal.WriteRaw
    )

instance ( ty ~ HsBindgen.Runtime.LibC.CSigAtomic
         ) => BG.CompatHasField.HasField "unwrapStdlib_CSigAtomic" Stdlib_CSigAtomic ty where

  hasField =
    \x0 ->
      ( \y1 ->
          Stdlib_CSigAtomic {unwrapStdlib_CSigAtomic = y1}
      , BG.getField @"unwrapStdlib_CSigAtomic" x0
      )

instance ( ty ~ HsBindgen.Runtime.LibC.CSigAtomic
         ) => BG.HasField "unwrapStdlib_CSigAtomic" (BG.Ptr Stdlib_CSigAtomic) (BG.Ptr ty) where

  getField =
    HasCField.fromPtr (BG.Proxy @"unwrapStdlib_CSigAtomic")

instance HasCField.HasCField Stdlib_CSigAtomic "unwrapStdlib_CSigAtomic" where

  type CFieldType Stdlib_CSigAtomic "unwrapStdlib_CSigAtomic" =
    HsBindgen.Runtime.LibC.CSigAtomic

  offset# = \_ -> \_ -> 0