{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Structs.TargetEntry
(
TargetEntry(..) ,
newZeroTargetEntry ,
#if defined(ENABLE_OVERLOADING)
ResolveTargetEntryMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TargetEntryCopyMethodInfo ,
#endif
targetEntryCopy ,
#if defined(ENABLE_OVERLOADING)
TargetEntryFreeMethodInfo ,
#endif
targetEntryFree ,
targetEntryNew ,
getTargetEntryFlags ,
setTargetEntryFlags ,
#if defined(ENABLE_OVERLOADING)
targetEntry_flags ,
#endif
getTargetEntryInfo ,
setTargetEntryInfo ,
#if defined(ENABLE_OVERLOADING)
targetEntry_info ,
#endif
clearTargetEntryTarget ,
getTargetEntryTarget ,
setTargetEntryTarget ,
#if defined(ENABLE_OVERLOADING)
targetEntry_target ,
#endif
) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
newtype TargetEntry = TargetEntry (SP.ManagedPtr TargetEntry)
deriving (TargetEntry -> TargetEntry -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TargetEntry -> TargetEntry -> Bool
$c/= :: TargetEntry -> TargetEntry -> Bool
== :: TargetEntry -> TargetEntry -> Bool
$c== :: TargetEntry -> TargetEntry -> Bool
Eq)
instance SP.ManagedPtrNewtype TargetEntry where
toManagedPtr :: TargetEntry -> ManagedPtr TargetEntry
toManagedPtr (TargetEntry ManagedPtr TargetEntry
p) = ManagedPtr TargetEntry
p
foreign import ccall "gtk_target_entry_get_type" c_gtk_target_entry_get_type ::
IO GType
type instance O.ParentTypes TargetEntry = '[]
instance O.HasParentTypes TargetEntry
instance B.Types.TypedObject TargetEntry where
glibType :: IO GType
glibType = IO GType
c_gtk_target_entry_get_type
instance B.Types.GBoxed TargetEntry
instance B.GValue.IsGValue (Maybe TargetEntry) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_target_entry_get_type
gvalueSet_ :: Ptr GValue -> Maybe TargetEntry -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TargetEntry
P.Nothing = forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr TargetEntry)
gvalueSet_ Ptr GValue
gv (P.Just TargetEntry
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TargetEntry
obj (forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe TargetEntry)
gvalueGet_ Ptr GValue
gv = do
Ptr TargetEntry
ptr <- forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr TargetEntry)
if Ptr TargetEntry
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr TargetEntry -> TargetEntry
TargetEntry Ptr TargetEntry
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
newZeroTargetEntry :: MonadIO m => m TargetEntry
newZeroTargetEntry :: forall (m :: * -> *). MonadIO m => m TargetEntry
newZeroTargetEntry = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
16 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TargetEntry -> TargetEntry
TargetEntry
instance tag ~ 'AttrSet => Constructible TargetEntry tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr TargetEntry -> TargetEntry)
-> [AttrOp TargetEntry tag] -> m TargetEntry
new ManagedPtr TargetEntry -> TargetEntry
_ [AttrOp TargetEntry tag]
attrs = do
TargetEntry
o <- forall (m :: * -> *). MonadIO m => m TargetEntry
newZeroTargetEntry
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set TargetEntry
o [AttrOp TargetEntry tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return TargetEntry
o
getTargetEntryTarget :: MonadIO m => TargetEntry -> m (Maybe T.Text)
getTargetEntryTarget :: forall (m :: * -> *). MonadIO m => TargetEntry -> m (Maybe Text)
getTargetEntryTarget TargetEntry
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TargetEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr TargetEntry
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TargetEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CString
Maybe Text
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
cstringToText CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setTargetEntryTarget :: MonadIO m => TargetEntry -> CString -> m ()
setTargetEntryTarget :: forall (m :: * -> *). MonadIO m => TargetEntry -> CString -> m ()
setTargetEntryTarget TargetEntry
s CString
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TargetEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr TargetEntry
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TargetEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
val :: CString)
clearTargetEntryTarget :: MonadIO m => TargetEntry -> m ()
clearTargetEntryTarget :: forall (m :: * -> *). MonadIO m => TargetEntry -> m ()
clearTargetEntryTarget TargetEntry
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TargetEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr TargetEntry
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TargetEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data TargetEntryTargetFieldInfo
instance AttrInfo TargetEntryTargetFieldInfo where
type AttrBaseTypeConstraint TargetEntryTargetFieldInfo = (~) TargetEntry
type AttrAllowedOps TargetEntryTargetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TargetEntryTargetFieldInfo = (~) CString
type AttrTransferTypeConstraint TargetEntryTargetFieldInfo = (~)CString
type AttrTransferType TargetEntryTargetFieldInfo = CString
type AttrGetType TargetEntryTargetFieldInfo = Maybe T.Text
type AttrLabel TargetEntryTargetFieldInfo = "target"
type AttrOrigin TargetEntryTargetFieldInfo = TargetEntry
attrGet = getTargetEntryTarget
attrSet = setTargetEntryTarget
attrConstruct = undefined
attrClear = clearTargetEntryTarget
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.TargetEntry.target"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-TargetEntry.html#g:attr:target"
})
targetEntry_target :: AttrLabelProxy "target"
targetEntry_target = AttrLabelProxy
#endif
getTargetEntryFlags :: MonadIO m => TargetEntry -> m Word32
getTargetEntryFlags :: forall (m :: * -> *). MonadIO m => TargetEntry -> m Word32
getTargetEntryFlags TargetEntry
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TargetEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr TargetEntry
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TargetEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setTargetEntryFlags :: MonadIO m => TargetEntry -> Word32 -> m ()
setTargetEntryFlags :: forall (m :: * -> *). MonadIO m => TargetEntry -> Word32 -> m ()
setTargetEntryFlags TargetEntry
s Word32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TargetEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr TargetEntry
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TargetEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data TargetEntryFlagsFieldInfo
instance AttrInfo TargetEntryFlagsFieldInfo where
type AttrBaseTypeConstraint TargetEntryFlagsFieldInfo = (~) TargetEntry
type AttrAllowedOps TargetEntryFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint TargetEntryFlagsFieldInfo = (~) Word32
type AttrTransferTypeConstraint TargetEntryFlagsFieldInfo = (~)Word32
type AttrTransferType TargetEntryFlagsFieldInfo = Word32
type AttrGetType TargetEntryFlagsFieldInfo = Word32
type AttrLabel TargetEntryFlagsFieldInfo = "flags"
type AttrOrigin TargetEntryFlagsFieldInfo = TargetEntry
attrGet = getTargetEntryFlags
attrSet = setTargetEntryFlags
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.TargetEntry.flags"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-TargetEntry.html#g:attr:flags"
})
targetEntry_flags :: AttrLabelProxy "flags"
targetEntry_flags = AttrLabelProxy
#endif
getTargetEntryInfo :: MonadIO m => TargetEntry -> m Word32
getTargetEntryInfo :: forall (m :: * -> *). MonadIO m => TargetEntry -> m Word32
getTargetEntryInfo TargetEntry
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TargetEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr TargetEntry
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TargetEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setTargetEntryInfo :: MonadIO m => TargetEntry -> Word32 -> m ()
setTargetEntryInfo :: forall (m :: * -> *). MonadIO m => TargetEntry -> Word32 -> m ()
setTargetEntryInfo TargetEntry
s Word32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TargetEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr TargetEntry
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TargetEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data TargetEntryInfoFieldInfo
instance AttrInfo TargetEntryInfoFieldInfo where
type AttrBaseTypeConstraint TargetEntryInfoFieldInfo = (~) TargetEntry
type AttrAllowedOps TargetEntryInfoFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint TargetEntryInfoFieldInfo = (~) Word32
type AttrTransferTypeConstraint TargetEntryInfoFieldInfo = (~)Word32
type AttrTransferType TargetEntryInfoFieldInfo = Word32
type AttrGetType TargetEntryInfoFieldInfo = Word32
type AttrLabel TargetEntryInfoFieldInfo = "info"
type AttrOrigin TargetEntryInfoFieldInfo = TargetEntry
attrGet = getTargetEntryInfo
attrSet = setTargetEntryInfo
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.TargetEntry.info"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-TargetEntry.html#g:attr:info"
})
targetEntry_info :: AttrLabelProxy "info"
targetEntry_info = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TargetEntry
type instance O.AttributeList TargetEntry = TargetEntryAttributeList
type TargetEntryAttributeList = ('[ '("target", TargetEntryTargetFieldInfo), '("flags", TargetEntryFlagsFieldInfo), '("info", TargetEntryInfoFieldInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "gtk_target_entry_new" gtk_target_entry_new ::
CString ->
Word32 ->
Word32 ->
IO (Ptr TargetEntry)
targetEntryNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Word32
-> Word32
-> m TargetEntry
targetEntryNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Word32 -> Word32 -> m TargetEntry
targetEntryNew Text
target Word32
flags Word32
info = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
target' <- Text -> IO CString
textToCString Text
target
Ptr TargetEntry
result <- CString -> Word32 -> Word32 -> IO (Ptr TargetEntry)
gtk_target_entry_new CString
target' Word32
flags Word32
info
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"targetEntryNew" Ptr TargetEntry
result
TargetEntry
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TargetEntry -> TargetEntry
TargetEntry) Ptr TargetEntry
result
forall a. Ptr a -> IO ()
freeMem CString
target'
forall (m :: * -> *) a. Monad m => a -> m a
return TargetEntry
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gtk_target_entry_copy" gtk_target_entry_copy ::
Ptr TargetEntry ->
IO (Ptr TargetEntry)
targetEntryCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
TargetEntry
-> m TargetEntry
targetEntryCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TargetEntry -> m TargetEntry
targetEntryCopy TargetEntry
data_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TargetEntry
data_' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TargetEntry
data_
Ptr TargetEntry
result <- Ptr TargetEntry -> IO (Ptr TargetEntry)
gtk_target_entry_copy Ptr TargetEntry
data_'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"targetEntryCopy" Ptr TargetEntry
result
TargetEntry
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TargetEntry -> TargetEntry
TargetEntry) Ptr TargetEntry
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TargetEntry
data_
forall (m :: * -> *) a. Monad m => a -> m a
return TargetEntry
result'
#if defined(ENABLE_OVERLOADING)
data TargetEntryCopyMethodInfo
instance (signature ~ (m TargetEntry), MonadIO m) => O.OverloadedMethod TargetEntryCopyMethodInfo TargetEntry signature where
overloadedMethod = targetEntryCopy
instance O.OverloadedMethodInfo TargetEntryCopyMethodInfo TargetEntry where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.TargetEntry.targetEntryCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-TargetEntry.html#v:targetEntryCopy"
})
#endif
foreign import ccall "gtk_target_entry_free" gtk_target_entry_free ::
Ptr TargetEntry ->
IO ()
targetEntryFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
TargetEntry
-> m ()
targetEntryFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TargetEntry -> m ()
targetEntryFree TargetEntry
data_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TargetEntry
data_' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TargetEntry
data_
Ptr TargetEntry -> IO ()
gtk_target_entry_free Ptr TargetEntry
data_'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TargetEntry
data_
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TargetEntryFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod TargetEntryFreeMethodInfo TargetEntry signature where
overloadedMethod = targetEntryFree
instance O.OverloadedMethodInfo TargetEntryFreeMethodInfo TargetEntry where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.TargetEntry.targetEntryFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-TargetEntry.html#v:targetEntryFree"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTargetEntryMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveTargetEntryMethod "copy" o = TargetEntryCopyMethodInfo
ResolveTargetEntryMethod "free" o = TargetEntryFreeMethodInfo
ResolveTargetEntryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTargetEntryMethod t TargetEntry, O.OverloadedMethod info TargetEntry p) => OL.IsLabel t (TargetEntry -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTargetEntryMethod t TargetEntry, O.OverloadedMethod info TargetEntry p, R.HasField t TargetEntry p) => R.HasField t TargetEntry p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTargetEntryMethod t TargetEntry, O.OverloadedMethodInfo info TargetEntry) => OL.IsLabel t (O.MethodProxy info TargetEntry) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif