    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

    A set of functions used to perform memory allocation. The same 'GI.GLib.Structs.MemVTable.MemVTable' must
    be used for all allocations in the same program; a call to 'GI.GLib.Functions.memSetVtable',
    if it exists, should be prior to any use of GLib.

    This functions related to this has been deprecated in 2.46, and no longer work.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.GLib.Structs.MemVTable
        (

    -- * Exported types
        MemVTable(..)                           ,
        newZeroMemVTable                        ,
        noMemVTable                             ,

     -- * Properties
    -- ** calloc #attr:calloc#
    {- | /No description available in the introspection data./
    -}
        clearMemVTableCalloc                    ,
        getMemVTableCalloc                      ,
    #if ENABLE_OVERLOADING
        memVTable_calloc                        ,
    #endif
        setMemVTableCalloc                      ,

    -- ** free #attr:free#
    {- | /No description available in the introspection data./
    -}
        clearMemVTableFree                      ,
        getMemVTableFree                        ,
    #if ENABLE_OVERLOADING
        memVTable_free                          ,
    #endif
        setMemVTableFree                        ,

    -- ** malloc #attr:malloc#
    {- | /No description available in the introspection data./
    -}
        clearMemVTableMalloc                    ,
        getMemVTableMalloc                      ,
    #if ENABLE_OVERLOADING
        memVTable_malloc                        ,
    #endif
        setMemVTableMalloc                      ,

    -- ** realloc #attr:realloc#
    {- | /No description available in the introspection data./
    -}
        clearMemVTableRealloc                   ,
        getMemVTableRealloc                     ,
    #if ENABLE_OVERLOADING
        memVTable_realloc                       ,
    #endif
        setMemVTableRealloc                     ,

    -- ** tryMalloc #attr:tryMalloc#
    {- | /No description available in the introspection data./
    -}
        clearMemVTableTryMalloc                 ,
        getMemVTableTryMalloc                   ,
    #if ENABLE_OVERLOADING
        memVTable_tryMalloc                     ,
    #endif
        setMemVTableTryMalloc                   ,

    -- ** tryRealloc #attr:tryRealloc#
    {- | /No description available in the introspection data./
    -}
        clearMemVTableTryRealloc                ,
        getMemVTableTryRealloc                  ,
    #if ENABLE_OVERLOADING
        memVTable_tryRealloc                    ,
    #endif
        setMemVTableTryRealloc                  ,

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import qualified GI.GLib.Callbacks as GLib.Callbacks

    -- | Memory-managed wrapper type.
    newtype MemVTable = MemVTable (ManagedPtr MemVTable)
    instance WrappedPtr MemVTable where
        wrappedPtrCalloc = callocBytes 48
        wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 48 >=> wrapPtr MemVTable)
        wrappedPtrFree = Just ptr_to_g_free

    -- | Construct a `MemVTable` struct initialized to zero.
    newZeroMemVTable :: MonadIO m => m MemVTable
    newZeroMemVTable = liftIO $ wrappedPtrCalloc >>= wrapPtr MemVTable

    instance tag ~ 'AttrSet => Constructible MemVTable tag where
        new _ attrs = do
            o <- newZeroMemVTable
            GI.Attributes.set o attrs
            return o

    -- | A convenience alias for `Nothing` :: `Maybe` `MemVTable`.
    noMemVTable :: Maybe MemVTable
    noMemVTable = Nothing

    {- |
    Get the value of the “@malloc@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' memVTable #malloc
    @
    -}
    getMemVTableMalloc :: MonadIO m => MemVTable -> m (Maybe GLib.Callbacks.MemVTableMallocFieldCallback)
    getMemVTableMalloc s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 0) :: IO (FunPtr GLib.Callbacks.C_MemVTableMallocFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \val' -> do
            let val'' = GLib.Callbacks.dynamic_MemVTableMallocFieldCallback val'
            return val''
        return result

    {- |
    Set the value of the “@malloc@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' memVTable [ #malloc 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setMemVTableMalloc :: MonadIO m => MemVTable -> FunPtr GLib.Callbacks.C_MemVTableMallocFieldCallback -> m ()
    setMemVTableMalloc s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 0) (val :: FunPtr GLib.Callbacks.C_MemVTableMallocFieldCallback)

    {- |
    Set the value of the “@malloc@” field to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #malloc
    @
    -}
    clearMemVTableMalloc :: MonadIO m => MemVTable -> m ()
    clearMemVTableMalloc s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 0) (FP.nullFunPtr :: FunPtr GLib.Callbacks.C_MemVTableMallocFieldCallback)

    #if ENABLE_OVERLOADING
    data MemVTableMallocFieldInfo
    instance AttrInfo MemVTableMallocFieldInfo where
        type AttrAllowedOps MemVTableMallocFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint MemVTableMallocFieldInfo = (~) (FunPtr GLib.Callbacks.C_MemVTableMallocFieldCallback)
        type AttrBaseTypeConstraint MemVTableMallocFieldInfo = (~) MemVTable
        type AttrGetType MemVTableMallocFieldInfo = Maybe GLib.Callbacks.MemVTableMallocFieldCallback
        type AttrLabel MemVTableMallocFieldInfo = "malloc"
        type AttrOrigin MemVTableMallocFieldInfo = MemVTable
        attrGet _ = getMemVTableMalloc
        attrSet _ = setMemVTableMalloc
        attrConstruct = undefined
        attrClear _ = clearMemVTableMalloc

    memVTable_malloc :: AttrLabelProxy "malloc"
    memVTable_malloc = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@realloc@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' memVTable #realloc
    @
    -}
    getMemVTableRealloc :: MonadIO m => MemVTable -> m (Maybe GLib.Callbacks.MemVTableReallocFieldCallback)
    getMemVTableRealloc s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 8) :: IO (FunPtr GLib.Callbacks.C_MemVTableReallocFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \val' -> do
            let val'' = GLib.Callbacks.dynamic_MemVTableReallocFieldCallback val'
            return val''
        return result

    {- |
    Set the value of the “@realloc@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' memVTable [ #realloc 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setMemVTableRealloc :: MonadIO m => MemVTable -> FunPtr GLib.Callbacks.C_MemVTableReallocFieldCallback -> m ()
    setMemVTableRealloc s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 8) (val :: FunPtr GLib.Callbacks.C_MemVTableReallocFieldCallback)

    {- |
    Set the value of the “@realloc@” field to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #realloc
    @
    -}
    clearMemVTableRealloc :: MonadIO m => MemVTable -> m ()
    clearMemVTableRealloc s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 8) (FP.nullFunPtr :: FunPtr GLib.Callbacks.C_MemVTableReallocFieldCallback)

    #if ENABLE_OVERLOADING
    data MemVTableReallocFieldInfo
    instance AttrInfo MemVTableReallocFieldInfo where
        type AttrAllowedOps MemVTableReallocFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint MemVTableReallocFieldInfo = (~) (FunPtr GLib.Callbacks.C_MemVTableReallocFieldCallback)
        type AttrBaseTypeConstraint MemVTableReallocFieldInfo = (~) MemVTable
        type AttrGetType MemVTableReallocFieldInfo = Maybe GLib.Callbacks.MemVTableReallocFieldCallback
        type AttrLabel MemVTableReallocFieldInfo = "realloc"
        type AttrOrigin MemVTableReallocFieldInfo = MemVTable
        attrGet _ = getMemVTableRealloc
        attrSet _ = setMemVTableRealloc
        attrConstruct = undefined
        attrClear _ = clearMemVTableRealloc

    memVTable_realloc :: AttrLabelProxy "realloc"
    memVTable_realloc = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@free@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' memVTable #free
    @
    -}
    getMemVTableFree :: MonadIO m => MemVTable -> m (Maybe GLib.Callbacks.MemVTableFreeFieldCallback)
    getMemVTableFree s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 16) :: IO (FunPtr GLib.Callbacks.C_MemVTableFreeFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \val' -> do
            let val'' = GLib.Callbacks.dynamic_MemVTableFreeFieldCallback val'
            return val''
        return result

    {- |
    Set the value of the “@free@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' memVTable [ #free 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setMemVTableFree :: MonadIO m => MemVTable -> FunPtr GLib.Callbacks.C_MemVTableFreeFieldCallback -> m ()
    setMemVTableFree s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 16) (val :: FunPtr GLib.Callbacks.C_MemVTableFreeFieldCallback)

    {- |
    Set the value of the “@free@” field to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #free
    @
    -}
    clearMemVTableFree :: MonadIO m => MemVTable -> m ()
    clearMemVTableFree s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 16) (FP.nullFunPtr :: FunPtr GLib.Callbacks.C_MemVTableFreeFieldCallback)

    #if ENABLE_OVERLOADING
    data MemVTableFreeFieldInfo
    instance AttrInfo MemVTableFreeFieldInfo where
        type AttrAllowedOps MemVTableFreeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint MemVTableFreeFieldInfo = (~) (FunPtr GLib.Callbacks.C_MemVTableFreeFieldCallback)
        type AttrBaseTypeConstraint MemVTableFreeFieldInfo = (~) MemVTable
        type AttrGetType MemVTableFreeFieldInfo = Maybe GLib.Callbacks.MemVTableFreeFieldCallback
        type AttrLabel MemVTableFreeFieldInfo = "free"
        type AttrOrigin MemVTableFreeFieldInfo = MemVTable
        attrGet _ = getMemVTableFree
        attrSet _ = setMemVTableFree
        attrConstruct = undefined
        attrClear _ = clearMemVTableFree

    memVTable_free :: AttrLabelProxy "free"
    memVTable_free = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@calloc@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' memVTable #calloc
    @
    -}
    getMemVTableCalloc :: MonadIO m => MemVTable -> m (Maybe GLib.Callbacks.MemVTableCallocFieldCallback)
    getMemVTableCalloc s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 24) :: IO (FunPtr GLib.Callbacks.C_MemVTableCallocFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \val' -> do
            let val'' = GLib.Callbacks.dynamic_MemVTableCallocFieldCallback val'
            return val''
        return result

    {- |
    Set the value of the “@calloc@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' memVTable [ #calloc 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setMemVTableCalloc :: MonadIO m => MemVTable -> FunPtr GLib.Callbacks.C_MemVTableCallocFieldCallback -> m ()
    setMemVTableCalloc s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 24) (val :: FunPtr GLib.Callbacks.C_MemVTableCallocFieldCallback)

    {- |
    Set the value of the “@calloc@” field to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #calloc
    @
    -}
    clearMemVTableCalloc :: MonadIO m => MemVTable -> m ()
    clearMemVTableCalloc s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 24) (FP.nullFunPtr :: FunPtr GLib.Callbacks.C_MemVTableCallocFieldCallback)

    #if ENABLE_OVERLOADING
    data MemVTableCallocFieldInfo
    instance AttrInfo MemVTableCallocFieldInfo where
        type AttrAllowedOps MemVTableCallocFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint MemVTableCallocFieldInfo = (~) (FunPtr GLib.Callbacks.C_MemVTableCallocFieldCallback)
        type AttrBaseTypeConstraint MemVTableCallocFieldInfo = (~) MemVTable
        type AttrGetType MemVTableCallocFieldInfo = Maybe GLib.Callbacks.MemVTableCallocFieldCallback
        type AttrLabel MemVTableCallocFieldInfo = "calloc"
        type AttrOrigin MemVTableCallocFieldInfo = MemVTable
        attrGet _ = getMemVTableCalloc
        attrSet _ = setMemVTableCalloc
        attrConstruct = undefined
        attrClear _ = clearMemVTableCalloc

    memVTable_calloc :: AttrLabelProxy "calloc"
    memVTable_calloc = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@try_malloc@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' memVTable #tryMalloc
    @
    -}
    getMemVTableTryMalloc :: MonadIO m => MemVTable -> m (Maybe GLib.Callbacks.MemVTableTryMallocFieldCallback)
    getMemVTableTryMalloc s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 32) :: IO (FunPtr GLib.Callbacks.C_MemVTableTryMallocFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \val' -> do
            let val'' = GLib.Callbacks.dynamic_MemVTableTryMallocFieldCallback val'
            return val''
        return result

    {- |
    Set the value of the “@try_malloc@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' memVTable [ #tryMalloc 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setMemVTableTryMalloc :: MonadIO m => MemVTable -> FunPtr GLib.Callbacks.C_MemVTableTryMallocFieldCallback -> m ()
    setMemVTableTryMalloc s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 32) (val :: FunPtr GLib.Callbacks.C_MemVTableTryMallocFieldCallback)

    {- |
    Set the value of the “@try_malloc@” field to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #tryMalloc
    @
    -}
    clearMemVTableTryMalloc :: MonadIO m => MemVTable -> m ()
    clearMemVTableTryMalloc s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 32) (FP.nullFunPtr :: FunPtr GLib.Callbacks.C_MemVTableTryMallocFieldCallback)

    #if ENABLE_OVERLOADING
    data MemVTableTryMallocFieldInfo
    instance AttrInfo MemVTableTryMallocFieldInfo where
        type AttrAllowedOps MemVTableTryMallocFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint MemVTableTryMallocFieldInfo = (~) (FunPtr GLib.Callbacks.C_MemVTableTryMallocFieldCallback)
        type AttrBaseTypeConstraint MemVTableTryMallocFieldInfo = (~) MemVTable
        type AttrGetType MemVTableTryMallocFieldInfo = Maybe GLib.Callbacks.MemVTableTryMallocFieldCallback
        type AttrLabel MemVTableTryMallocFieldInfo = "try_malloc"
        type AttrOrigin MemVTableTryMallocFieldInfo = MemVTable
        attrGet _ = getMemVTableTryMalloc
        attrSet _ = setMemVTableTryMalloc
        attrConstruct = undefined
        attrClear _ = clearMemVTableTryMalloc

    memVTable_tryMalloc :: AttrLabelProxy "tryMalloc"
    memVTable_tryMalloc = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@try_realloc@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' memVTable #tryRealloc
    @
    -}
    getMemVTableTryRealloc :: MonadIO m => MemVTable -> m (Maybe GLib.Callbacks.MemVTableTryReallocFieldCallback)
    getMemVTableTryRealloc s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 40) :: IO (FunPtr GLib.Callbacks.C_MemVTableTryReallocFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \val' -> do
            let val'' = GLib.Callbacks.dynamic_MemVTableTryReallocFieldCallback val'
            return val''
        return result

    {- |
    Set the value of the “@try_realloc@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' memVTable [ #tryRealloc 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setMemVTableTryRealloc :: MonadIO m => MemVTable -> FunPtr GLib.Callbacks.C_MemVTableTryReallocFieldCallback -> m ()
    setMemVTableTryRealloc s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 40) (val :: FunPtr GLib.Callbacks.C_MemVTableTryReallocFieldCallback)

    {- |
    Set the value of the “@try_realloc@” field to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #tryRealloc
    @
    -}
    clearMemVTableTryRealloc :: MonadIO m => MemVTable -> m ()
    clearMemVTableTryRealloc s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 40) (FP.nullFunPtr :: FunPtr GLib.Callbacks.C_MemVTableTryReallocFieldCallback)

    #if ENABLE_OVERLOADING
    data MemVTableTryReallocFieldInfo
    instance AttrInfo MemVTableTryReallocFieldInfo where
        type AttrAllowedOps MemVTableTryReallocFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint MemVTableTryReallocFieldInfo = (~) (FunPtr GLib.Callbacks.C_MemVTableTryReallocFieldCallback)
        type AttrBaseTypeConstraint MemVTableTryReallocFieldInfo = (~) MemVTable
        type AttrGetType MemVTableTryReallocFieldInfo = Maybe GLib.Callbacks.MemVTableTryReallocFieldCallback
        type AttrLabel MemVTableTryReallocFieldInfo = "try_realloc"
        type AttrOrigin MemVTableTryReallocFieldInfo = MemVTable
        attrGet _ = getMemVTableTryRealloc
        attrSet _ = setMemVTableTryRealloc
        attrConstruct = undefined
        attrClear _ = clearMemVTableTryRealloc

    memVTable_tryRealloc :: AttrLabelProxy "tryRealloc"
    memVTable_tryRealloc = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList MemVTable
    type instance O.AttributeList MemVTable = MemVTableAttributeList
    type MemVTableAttributeList = ('[ '("malloc", MemVTableMallocFieldInfo), '("realloc", MemVTableReallocFieldInfo), '("free", MemVTableFreeFieldInfo), '("calloc", MemVTableCallocFieldInfo), '("tryMalloc", MemVTableTryMallocFieldInfo), '("tryRealloc", MemVTableTryReallocFieldInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    type family ResolveMemVTableMethod (t :: Symbol) (o :: *) :: * where
        ResolveMemVTableMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveMemVTableMethod t MemVTable, O.MethodInfo info MemVTable p) => O.IsLabelProxy t (MemVTable -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveMemVTableMethod t MemVTable, O.MethodInfo info MemVTable p) => O.IsLabel t (MemVTable -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #else
        fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #endif
    #endif

    #endif