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

The 'GI.GLib.Structs.HookList.HookList' struct represents a list of hook functions.
-}

module GI.GLib.Structs.HookList
    ( 

-- * Exported types
    HookList(..)                            ,
    newZeroHookList                         ,
    noHookList                              ,


 -- * Methods
-- ** clear #method:clear#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    HookListClearMethodInfo                 ,
#endif
    hookListClear                           ,


-- ** init #method:init#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    HookListInitMethodInfo                  ,
#endif
    hookListInit                            ,


-- ** invoke #method:invoke#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    HookListInvokeMethodInfo                ,
#endif
    hookListInvoke                          ,


-- ** invokeCheck #method:invokeCheck#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    HookListInvokeCheckMethodInfo           ,
#endif
    hookListInvokeCheck                     ,




 -- * Properties
-- ** dummy3 #attr:dummy3#
    clearHookListDummy3                     ,
    getHookListDummy3                       ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    hookList_dummy3                         ,
#endif
    setHookListDummy3                       ,


-- ** finalizeHook #attr:finalizeHook#
    clearHookListFinalizeHook               ,
    getHookListFinalizeHook                 ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    hookList_finalizeHook                   ,
#endif
    setHookListFinalizeHook                 ,


-- ** hookSize #attr:hookSize#
    getHookListHookSize                     ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    hookList_hookSize                       ,
#endif
    setHookListHookSize                     ,


-- ** hooks #attr:hooks#
    clearHookListHooks                      ,
    getHookListHooks                        ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    hookList_hooks                          ,
#endif
    setHookListHooks                        ,


-- ** isSetup #attr:isSetup#
    getHookListIsSetup                      ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    hookList_isSetup                        ,
#endif
    setHookListIsSetup                      ,


-- ** seqId #attr:seqId#
    getHookListSeqId                        ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    hookList_seqId                          ,
#endif
    setHookListSeqId                        ,




    ) 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.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
import {-# SOURCE #-} qualified GI.GLib.Structs.Hook as GLib.Hook

newtype HookList = HookList (ManagedPtr HookList)
instance WrappedPtr HookList where
    wrappedPtrCalloc = callocBytes 56
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 56 >=> wrapPtr HookList)
    wrappedPtrFree = Just ptr_to_g_free

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

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


noHookList :: Maybe HookList
noHookList = Nothing

getHookListSeqId :: MonadIO m => HookList -> m CULong
getHookListSeqId s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CULong
    return val

setHookListSeqId :: MonadIO m => HookList -> CULong -> m ()
setHookListSeqId s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: CULong)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookListSeqIdFieldInfo
instance AttrInfo HookListSeqIdFieldInfo where
    type AttrAllowedOps HookListSeqIdFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint HookListSeqIdFieldInfo = (~) CULong
    type AttrBaseTypeConstraint HookListSeqIdFieldInfo = (~) HookList
    type AttrGetType HookListSeqIdFieldInfo = CULong
    type AttrLabel HookListSeqIdFieldInfo = "seq_id"
    type AttrOrigin HookListSeqIdFieldInfo = HookList
    attrGet _ = getHookListSeqId
    attrSet _ = setHookListSeqId
    attrConstruct = undefined
    attrClear _ = undefined

hookList_seqId :: AttrLabelProxy "seqId"
hookList_seqId = AttrLabelProxy

#endif


getHookListHookSize :: MonadIO m => HookList -> m Word32
getHookListHookSize s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO Word32
    return val

setHookListHookSize :: MonadIO m => HookList -> Word32 -> m ()
setHookListHookSize s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Word32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookListHookSizeFieldInfo
instance AttrInfo HookListHookSizeFieldInfo where
    type AttrAllowedOps HookListHookSizeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint HookListHookSizeFieldInfo = (~) Word32
    type AttrBaseTypeConstraint HookListHookSizeFieldInfo = (~) HookList
    type AttrGetType HookListHookSizeFieldInfo = Word32
    type AttrLabel HookListHookSizeFieldInfo = "hook_size"
    type AttrOrigin HookListHookSizeFieldInfo = HookList
    attrGet _ = getHookListHookSize
    attrSet _ = setHookListHookSize
    attrConstruct = undefined
    attrClear _ = undefined

hookList_hookSize :: AttrLabelProxy "hookSize"
hookList_hookSize = AttrLabelProxy

#endif


getHookListIsSetup :: MonadIO m => HookList -> m Word32
getHookListIsSetup s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 12) :: IO Word32
    return val

setHookListIsSetup :: MonadIO m => HookList -> Word32 -> m ()
setHookListIsSetup s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 12) (val :: Word32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookListIsSetupFieldInfo
instance AttrInfo HookListIsSetupFieldInfo where
    type AttrAllowedOps HookListIsSetupFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint HookListIsSetupFieldInfo = (~) Word32
    type AttrBaseTypeConstraint HookListIsSetupFieldInfo = (~) HookList
    type AttrGetType HookListIsSetupFieldInfo = Word32
    type AttrLabel HookListIsSetupFieldInfo = "is_setup"
    type AttrOrigin HookListIsSetupFieldInfo = HookList
    attrGet _ = getHookListIsSetup
    attrSet _ = setHookListIsSetup
    attrConstruct = undefined
    attrClear _ = undefined

hookList_isSetup :: AttrLabelProxy "isSetup"
hookList_isSetup = AttrLabelProxy

#endif


getHookListHooks :: MonadIO m => HookList -> m (Maybe GLib.Hook.Hook)
getHookListHooks s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO (Ptr GLib.Hook.Hook)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newPtr GLib.Hook.Hook) val'
        return val''
    return result

setHookListHooks :: MonadIO m => HookList -> Ptr GLib.Hook.Hook -> m ()
setHookListHooks s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Ptr GLib.Hook.Hook)

clearHookListHooks :: MonadIO m => HookList -> m ()
clearHookListHooks s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr GLib.Hook.Hook)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookListHooksFieldInfo
instance AttrInfo HookListHooksFieldInfo where
    type AttrAllowedOps HookListHooksFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint HookListHooksFieldInfo = (~) (Ptr GLib.Hook.Hook)
    type AttrBaseTypeConstraint HookListHooksFieldInfo = (~) HookList
    type AttrGetType HookListHooksFieldInfo = Maybe GLib.Hook.Hook
    type AttrLabel HookListHooksFieldInfo = "hooks"
    type AttrOrigin HookListHooksFieldInfo = HookList
    attrGet _ = getHookListHooks
    attrSet _ = setHookListHooks
    attrConstruct = undefined
    attrClear _ = clearHookListHooks

hookList_hooks :: AttrLabelProxy "hooks"
hookList_hooks = AttrLabelProxy

#endif


getHookListDummy3 :: MonadIO m => HookList -> m (Ptr ())
getHookListDummy3 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO (Ptr ())
    return val

setHookListDummy3 :: MonadIO m => HookList -> Ptr () -> m ()
setHookListDummy3 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Ptr ())

clearHookListDummy3 :: MonadIO m => HookList -> m ()
clearHookListDummy3 s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (FP.nullPtr :: Ptr ())

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookListDummy3FieldInfo
instance AttrInfo HookListDummy3FieldInfo where
    type AttrAllowedOps HookListDummy3FieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint HookListDummy3FieldInfo = (~) (Ptr ())
    type AttrBaseTypeConstraint HookListDummy3FieldInfo = (~) HookList
    type AttrGetType HookListDummy3FieldInfo = Ptr ()
    type AttrLabel HookListDummy3FieldInfo = "dummy3"
    type AttrOrigin HookListDummy3FieldInfo = HookList
    attrGet _ = getHookListDummy3
    attrSet _ = setHookListDummy3
    attrConstruct = undefined
    attrClear _ = clearHookListDummy3

hookList_dummy3 :: AttrLabelProxy "dummy3"
hookList_dummy3 = AttrLabelProxy

#endif


getHookListFinalizeHook :: MonadIO m => HookList -> m (Maybe GLib.Callbacks.HookFinalizeFunc)
getHookListFinalizeHook s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO (FunPtr GLib.Callbacks.C_HookFinalizeFunc)
    result <- SP.convertFunPtrIfNonNull val $ \val' -> do
        let val'' = GLib.Callbacks.dynamic_HookFinalizeFunc val'
        return val''
    return result

setHookListFinalizeHook :: MonadIO m => HookList -> FunPtr GLib.Callbacks.C_HookFinalizeFunc -> m ()
setHookListFinalizeHook s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: FunPtr GLib.Callbacks.C_HookFinalizeFunc)

clearHookListFinalizeHook :: MonadIO m => HookList -> m ()
clearHookListFinalizeHook s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (FP.nullFunPtr :: FunPtr GLib.Callbacks.C_HookFinalizeFunc)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookListFinalizeHookFieldInfo
instance AttrInfo HookListFinalizeHookFieldInfo where
    type AttrAllowedOps HookListFinalizeHookFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint HookListFinalizeHookFieldInfo = (~) (FunPtr GLib.Callbacks.C_HookFinalizeFunc)
    type AttrBaseTypeConstraint HookListFinalizeHookFieldInfo = (~) HookList
    type AttrGetType HookListFinalizeHookFieldInfo = Maybe GLib.Callbacks.HookFinalizeFunc
    type AttrLabel HookListFinalizeHookFieldInfo = "finalize_hook"
    type AttrOrigin HookListFinalizeHookFieldInfo = HookList
    attrGet _ = getHookListFinalizeHook
    attrSet _ = setHookListFinalizeHook
    attrConstruct = undefined
    attrClear _ = clearHookListFinalizeHook

hookList_finalizeHook :: AttrLabelProxy "finalizeHook"
hookList_finalizeHook = AttrLabelProxy

#endif


-- XXX Skipped attribute for "HookList:dummy" :: Not implemented: "Don't know how to unpack C array of type TCArray False 2 (-1) (TBasicType TPtr)"

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList HookList
type instance O.AttributeList HookList = HookListAttributeList
type HookListAttributeList = ('[ '("seqId", HookListSeqIdFieldInfo), '("hookSize", HookListHookSizeFieldInfo), '("isSetup", HookListIsSetupFieldInfo), '("hooks", HookListHooksFieldInfo), '("dummy3", HookListDummy3FieldInfo), '("finalizeHook", HookListFinalizeHookFieldInfo)] :: [(Symbol, *)])
#endif

-- method HookList::clear
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hook_list", argType = TInterface (Name {namespace = "GLib", name = "HookList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GHookList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_hook_list_clear" g_hook_list_clear :: 
    Ptr HookList ->                         -- hook_list : TInterface (Name {namespace = "GLib", name = "HookList"})
    IO ()

{- |
Removes all the 'GI.GLib.Structs.Hook.Hook' elements from a 'GI.GLib.Structs.HookList.HookList'.
-}
hookListClear ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    HookList
    {- ^ /@hookList@/: a 'GI.GLib.Structs.HookList.HookList' -}
    -> m ()
hookListClear hookList = liftIO $ do
    hookList' <- unsafeManagedPtrGetPtr hookList
    g_hook_list_clear hookList'
    touchManagedPtr hookList
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookListClearMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo HookListClearMethodInfo HookList signature where
    overloadedMethod _ = hookListClear

#endif

-- method HookList::init
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hook_list", argType = TInterface (Name {namespace = "GLib", name = "HookList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GHookList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hook_size", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of each element in the #GHookList,\n    typically `sizeof (GHook)`.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_hook_list_init" g_hook_list_init :: 
    Ptr HookList ->                         -- hook_list : TInterface (Name {namespace = "GLib", name = "HookList"})
    Word32 ->                               -- hook_size : TBasicType TUInt
    IO ()

{- |
Initializes a 'GI.GLib.Structs.HookList.HookList'.
This must be called before the 'GI.GLib.Structs.HookList.HookList' is used.
-}
hookListInit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    HookList
    {- ^ /@hookList@/: a 'GI.GLib.Structs.HookList.HookList' -}
    -> Word32
    {- ^ /@hookSize@/: the size of each element in the 'GI.GLib.Structs.HookList.HookList',
    typically @sizeof (GHook)@. -}
    -> m ()
hookListInit hookList hookSize = liftIO $ do
    hookList' <- unsafeManagedPtrGetPtr hookList
    g_hook_list_init hookList' hookSize
    touchManagedPtr hookList
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookListInitMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo HookListInitMethodInfo HookList signature where
    overloadedMethod _ = hookListInit

#endif

-- method HookList::invoke
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hook_list", argType = TInterface (Name {namespace = "GLib", name = "HookList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GHookList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "may_recurse", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if functions which are already running\n    (e.g. in another thread) can be called. If set to %FALSE,\n    these are skipped", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_hook_list_invoke" g_hook_list_invoke :: 
    Ptr HookList ->                         -- hook_list : TInterface (Name {namespace = "GLib", name = "HookList"})
    CInt ->                                 -- may_recurse : TBasicType TBoolean
    IO ()

{- |
Calls all of the 'GI.GLib.Structs.Hook.Hook' functions in a 'GI.GLib.Structs.HookList.HookList'.
-}
hookListInvoke ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    HookList
    {- ^ /@hookList@/: a 'GI.GLib.Structs.HookList.HookList' -}
    -> Bool
    {- ^ /@mayRecurse@/: 'True' if functions which are already running
    (e.g. in another thread) can be called. If set to 'False',
    these are skipped -}
    -> m ()
hookListInvoke hookList mayRecurse = liftIO $ do
    hookList' <- unsafeManagedPtrGetPtr hookList
    let mayRecurse' = (fromIntegral . fromEnum) mayRecurse
    g_hook_list_invoke hookList' mayRecurse'
    touchManagedPtr hookList
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookListInvokeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo HookListInvokeMethodInfo HookList signature where
    overloadedMethod _ = hookListInvoke

#endif

-- method HookList::invoke_check
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hook_list", argType = TInterface (Name {namespace = "GLib", name = "HookList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GHookList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "may_recurse", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if functions which are already running\n    (e.g. in another thread) can be called. If set to %FALSE,\n    these are skipped", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_hook_list_invoke_check" g_hook_list_invoke_check :: 
    Ptr HookList ->                         -- hook_list : TInterface (Name {namespace = "GLib", name = "HookList"})
    CInt ->                                 -- may_recurse : TBasicType TBoolean
    IO ()

{- |
Calls all of the 'GI.GLib.Structs.Hook.Hook' functions in a 'GI.GLib.Structs.HookList.HookList'.
Any function which returns 'False' is removed from the 'GI.GLib.Structs.HookList.HookList'.
-}
hookListInvokeCheck ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    HookList
    {- ^ /@hookList@/: a 'GI.GLib.Structs.HookList.HookList' -}
    -> Bool
    {- ^ /@mayRecurse@/: 'True' if functions which are already running
    (e.g. in another thread) can be called. If set to 'False',
    these are skipped -}
    -> m ()
hookListInvokeCheck hookList mayRecurse = liftIO $ do
    hookList' <- unsafeManagedPtrGetPtr hookList
    let mayRecurse' = (fromIntegral . fromEnum) mayRecurse
    g_hook_list_invoke_check hookList' mayRecurse'
    touchManagedPtr hookList
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data HookListInvokeCheckMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo HookListInvokeCheckMethodInfo HookList signature where
    overloadedMethod _ = hookListInvokeCheck

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveHookListMethod (t :: Symbol) (o :: *) :: * where
    ResolveHookListMethod "clear" o = HookListClearMethodInfo
    ResolveHookListMethod "init" o = HookListInitMethodInfo
    ResolveHookListMethod "invoke" o = HookListInvokeMethodInfo
    ResolveHookListMethod "invokeCheck" o = HookListInvokeCheckMethodInfo
    ResolveHookListMethod l o = O.MethodResolutionFailed l o

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

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveHookListMethod t HookList, O.MethodInfo info HookList p) => O.IsLabel t (HookList -> 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