#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Dbusmenu.Callbacks
(
C_ClientTypeHandler ,
ClientTypeHandler ,
ClientTypeHandler_WithClosures ,
drop_closures_ClientTypeHandler ,
dynamic_ClientTypeHandler ,
genClosure_ClientTypeHandler ,
mk_ClientTypeHandler ,
noClientTypeHandler ,
noClientTypeHandler_WithClosures ,
wrap_ClientTypeHandler ,
C_MenuitemAboutToShowCb ,
MenuitemAboutToShowCb ,
MenuitemAboutToShowCb_WithClosures ,
drop_closures_MenuitemAboutToShowCb ,
dynamic_MenuitemAboutToShowCb ,
genClosure_MenuitemAboutToShowCb ,
mk_MenuitemAboutToShowCb ,
noMenuitemAboutToShowCb ,
noMenuitemAboutToShowCb_WithClosures ,
wrap_MenuitemAboutToShowCb ,
C_MenuitemBuildvariantSlotT ,
MenuitemBuildvariantSlotT ,
dynamic_MenuitemBuildvariantSlotT ,
genClosure_MenuitemBuildvariantSlotT ,
mk_MenuitemBuildvariantSlotT ,
noMenuitemBuildvariantSlotT ,
wrap_MenuitemBuildvariantSlotT ,
) 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.GClosure as B.GClosure
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.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
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 GHC.OverloadedLabels as OL
import {-# SOURCE #-} qualified GI.Dbusmenu.Objects.Client as Dbusmenu.Client
import {-# SOURCE #-} qualified GI.Dbusmenu.Objects.Menuitem as Dbusmenu.Menuitem
type =
Ptr Dbusmenu.Menuitem.Menuitem ->
CString ->
IO (Ptr GVariant)
foreign import ccall "dynamic" :: FunPtr C_MenuitemBuildvariantSlotT -> C_MenuitemBuildvariantSlotT
dynamic_MenuitemBuildvariantSlotT ::
(B.CallStack.HasCallStack, MonadIO m, Dbusmenu.Menuitem.IsMenuitem a) =>
FunPtr C_MenuitemBuildvariantSlotT
-> a
-> Maybe (T.Text)
-> m GVariant
__funPtr :: FunPtr C_MenuitemBuildvariantSlotT
__funPtr mi :: a
mi properties :: Maybe Text
properties = IO GVariant -> m GVariant
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
Ptr Menuitem
mi' <- a -> IO (Ptr Menuitem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
mi
Ptr CChar
maybeProperties <- case Maybe Text
properties of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jProperties :: Text
jProperties -> do
Ptr CChar
jProperties' <- Text -> IO (Ptr CChar)
textToCString Text
jProperties
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jProperties'
Ptr GVariant
result <- (FunPtr C_MenuitemBuildvariantSlotT -> C_MenuitemBuildvariantSlotT
__dynamic_C_MenuitemBuildvariantSlotT FunPtr C_MenuitemBuildvariantSlotT
__funPtr) Ptr Menuitem
mi' Ptr CChar
maybeProperties
Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "menuitemBuildvariantSlotT" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
mi
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeProperties
GVariant -> IO GVariant
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
foreign import ccall "wrapper"
:: C_MenuitemBuildvariantSlotT -> IO (FunPtr C_MenuitemBuildvariantSlotT)
type =
Dbusmenu.Menuitem.Menuitem
-> Maybe T.Text
-> IO GVariant
noMenuitemBuildvariantSlotT :: Maybe MenuitemBuildvariantSlotT
= Maybe MenuitemBuildvariantSlotT
forall a. Maybe a
Nothing
genClosure_MenuitemBuildvariantSlotT :: MonadIO m => MenuitemBuildvariantSlotT -> m (GClosure C_MenuitemBuildvariantSlotT)
cb :: MenuitemBuildvariantSlotT
cb = IO (GClosure C_MenuitemBuildvariantSlotT)
-> m (GClosure C_MenuitemBuildvariantSlotT)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_MenuitemBuildvariantSlotT)
-> m (GClosure C_MenuitemBuildvariantSlotT))
-> IO (GClosure C_MenuitemBuildvariantSlotT)
-> m (GClosure C_MenuitemBuildvariantSlotT)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_MenuitemBuildvariantSlotT
cb' = Maybe (Ptr (FunPtr C_MenuitemBuildvariantSlotT))
-> MenuitemBuildvariantSlotT -> C_MenuitemBuildvariantSlotT
wrap_MenuitemBuildvariantSlotT Maybe (Ptr (FunPtr C_MenuitemBuildvariantSlotT))
forall a. Maybe a
Nothing MenuitemBuildvariantSlotT
cb
C_MenuitemBuildvariantSlotT
-> IO (FunPtr C_MenuitemBuildvariantSlotT)
mk_MenuitemBuildvariantSlotT C_MenuitemBuildvariantSlotT
cb' IO (FunPtr C_MenuitemBuildvariantSlotT)
-> (FunPtr C_MenuitemBuildvariantSlotT
-> IO (GClosure C_MenuitemBuildvariantSlotT))
-> IO (GClosure C_MenuitemBuildvariantSlotT)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_MenuitemBuildvariantSlotT
-> IO (GClosure C_MenuitemBuildvariantSlotT)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_MenuitemBuildvariantSlotT ::
Maybe (Ptr (FunPtr C_MenuitemBuildvariantSlotT)) ->
MenuitemBuildvariantSlotT ->
C_MenuitemBuildvariantSlotT
funptrptr :: Maybe (Ptr (FunPtr C_MenuitemBuildvariantSlotT))
funptrptr _cb :: MenuitemBuildvariantSlotT
_cb mi :: Ptr Menuitem
mi properties :: Ptr CChar
properties = do
Menuitem
mi' <- ((ManagedPtr Menuitem -> Menuitem) -> Ptr Menuitem -> IO Menuitem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Menuitem -> Menuitem
Dbusmenu.Menuitem.Menuitem) Ptr Menuitem
mi
Maybe Text
maybeProperties <-
if Ptr CChar
properties Ptr CChar -> Ptr CChar -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr CChar
forall a. Ptr a
nullPtr
then Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
forall a. Maybe a
Nothing
else do
Text
properties' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
properties
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text -> IO (Maybe Text)) -> Maybe Text -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ Text -> Maybe Text
forall a. a -> Maybe a
Just Text
properties'
GVariant
result <- MenuitemBuildvariantSlotT
_cb Menuitem
mi' Maybe Text
maybeProperties
Maybe (Ptr (FunPtr C_MenuitemBuildvariantSlotT)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_MenuitemBuildvariantSlotT))
funptrptr
Ptr GVariant
result' <- GVariant -> IO (Ptr GVariant)
B.GVariant.disownGVariant GVariant
result
Ptr GVariant -> IO (Ptr GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
result'
type =
Ptr Dbusmenu.Menuitem.Menuitem ->
Ptr () ->
IO ()
foreign import ccall "dynamic" :: FunPtr C_MenuitemAboutToShowCb -> C_MenuitemAboutToShowCb
dynamic_MenuitemAboutToShowCb ::
(B.CallStack.HasCallStack, MonadIO m, Dbusmenu.Menuitem.IsMenuitem a) =>
FunPtr C_MenuitemAboutToShowCb
-> a
-> Ptr ()
-> m ()
__funPtr :: FunPtr C_MenuitemAboutToShowCb
__funPtr mi :: a
mi userData :: Ptr ()
userData = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Menuitem
mi' <- a -> IO (Ptr Menuitem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
mi
(FunPtr C_MenuitemAboutToShowCb -> C_MenuitemAboutToShowCb
__dynamic_C_MenuitemAboutToShowCb FunPtr C_MenuitemAboutToShowCb
__funPtr) Ptr Menuitem
mi' Ptr ()
userData
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
mi
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
:: C_MenuitemAboutToShowCb -> IO (FunPtr C_MenuitemAboutToShowCb)
type =
Dbusmenu.Menuitem.Menuitem
-> IO ()
noMenuitemAboutToShowCb :: Maybe MenuitemAboutToShowCb
= Maybe MenuitemAboutToShowCb
forall a. Maybe a
Nothing
type =
Dbusmenu.Menuitem.Menuitem
-> Ptr ()
-> IO ()
noMenuitemAboutToShowCb_WithClosures :: Maybe MenuitemAboutToShowCb_WithClosures
= Maybe MenuitemAboutToShowCb_WithClosures
forall a. Maybe a
Nothing
drop_closures_MenuitemAboutToShowCb :: MenuitemAboutToShowCb -> MenuitemAboutToShowCb_WithClosures
_f :: MenuitemAboutToShowCb
_f mi :: Menuitem
mi _ = MenuitemAboutToShowCb
_f Menuitem
mi
genClosure_MenuitemAboutToShowCb :: MonadIO m => MenuitemAboutToShowCb -> m (GClosure C_MenuitemAboutToShowCb)
cb :: MenuitemAboutToShowCb
cb = IO (GClosure C_MenuitemAboutToShowCb)
-> m (GClosure C_MenuitemAboutToShowCb)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_MenuitemAboutToShowCb)
-> m (GClosure C_MenuitemAboutToShowCb))
-> IO (GClosure C_MenuitemAboutToShowCb)
-> m (GClosure C_MenuitemAboutToShowCb)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: MenuitemAboutToShowCb_WithClosures
cb' = MenuitemAboutToShowCb -> MenuitemAboutToShowCb_WithClosures
drop_closures_MenuitemAboutToShowCb MenuitemAboutToShowCb
cb
let cb'' :: C_MenuitemAboutToShowCb
cb'' = Maybe (Ptr (FunPtr C_MenuitemAboutToShowCb))
-> MenuitemAboutToShowCb_WithClosures -> C_MenuitemAboutToShowCb
wrap_MenuitemAboutToShowCb Maybe (Ptr (FunPtr C_MenuitemAboutToShowCb))
forall a. Maybe a
Nothing MenuitemAboutToShowCb_WithClosures
cb'
C_MenuitemAboutToShowCb -> IO (FunPtr C_MenuitemAboutToShowCb)
mk_MenuitemAboutToShowCb C_MenuitemAboutToShowCb
cb'' IO (FunPtr C_MenuitemAboutToShowCb)
-> (FunPtr C_MenuitemAboutToShowCb
-> IO (GClosure C_MenuitemAboutToShowCb))
-> IO (GClosure C_MenuitemAboutToShowCb)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_MenuitemAboutToShowCb
-> IO (GClosure C_MenuitemAboutToShowCb)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_MenuitemAboutToShowCb ::
Maybe (Ptr (FunPtr C_MenuitemAboutToShowCb)) ->
MenuitemAboutToShowCb_WithClosures ->
C_MenuitemAboutToShowCb
funptrptr :: Maybe (Ptr (FunPtr C_MenuitemAboutToShowCb))
funptrptr _cb :: MenuitemAboutToShowCb_WithClosures
_cb mi :: Ptr Menuitem
mi userData :: Ptr ()
userData = do
Menuitem
mi' <- ((ManagedPtr Menuitem -> Menuitem) -> Ptr Menuitem -> IO Menuitem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Menuitem -> Menuitem
Dbusmenu.Menuitem.Menuitem) Ptr Menuitem
mi
MenuitemAboutToShowCb_WithClosures
_cb Menuitem
mi' Ptr ()
userData
Maybe (Ptr (FunPtr C_MenuitemAboutToShowCb)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_MenuitemAboutToShowCb))
funptrptr
type C_ClientTypeHandler =
Ptr Dbusmenu.Menuitem.Menuitem ->
Ptr Dbusmenu.Menuitem.Menuitem ->
Ptr Dbusmenu.Client.Client ->
Ptr () ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_ClientTypeHandler :: FunPtr C_ClientTypeHandler -> C_ClientTypeHandler
dynamic_ClientTypeHandler ::
(B.CallStack.HasCallStack, MonadIO m, Dbusmenu.Menuitem.IsMenuitem a, Dbusmenu.Menuitem.IsMenuitem b, Dbusmenu.Client.IsClient c) =>
FunPtr C_ClientTypeHandler
-> a
-> b
-> c
-> Ptr ()
-> m Bool
dynamic_ClientTypeHandler :: FunPtr C_ClientTypeHandler -> a -> b -> c -> Ptr () -> m Bool
dynamic_ClientTypeHandler __funPtr :: FunPtr C_ClientTypeHandler
__funPtr newitem :: a
newitem parent :: b
parent client :: c
client userData :: Ptr ()
userData = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Menuitem
newitem' <- a -> IO (Ptr Menuitem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
newitem
Ptr Menuitem
parent' <- b -> IO (Ptr Menuitem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
parent
Ptr Client
client' <- c -> IO (Ptr Client)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
client
CInt
result <- (FunPtr C_ClientTypeHandler -> C_ClientTypeHandler
__dynamic_C_ClientTypeHandler FunPtr C_ClientTypeHandler
__funPtr) Ptr Menuitem
newitem' Ptr Menuitem
parent' Ptr Client
client' Ptr ()
userData
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
newitem
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
parent
c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
client
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_ClientTypeHandler :: C_ClientTypeHandler -> IO (FunPtr C_ClientTypeHandler)
type ClientTypeHandler =
Dbusmenu.Menuitem.Menuitem
-> Dbusmenu.Menuitem.Menuitem
-> Dbusmenu.Client.Client
-> IO Bool
noClientTypeHandler :: Maybe ClientTypeHandler
noClientTypeHandler :: Maybe ClientTypeHandler
noClientTypeHandler = Maybe ClientTypeHandler
forall a. Maybe a
Nothing
type ClientTypeHandler_WithClosures =
Dbusmenu.Menuitem.Menuitem
-> Dbusmenu.Menuitem.Menuitem
-> Dbusmenu.Client.Client
-> Ptr ()
-> IO Bool
noClientTypeHandler_WithClosures :: Maybe ClientTypeHandler_WithClosures
noClientTypeHandler_WithClosures :: Maybe ClientTypeHandler_WithClosures
noClientTypeHandler_WithClosures = Maybe ClientTypeHandler_WithClosures
forall a. Maybe a
Nothing
drop_closures_ClientTypeHandler :: ClientTypeHandler -> ClientTypeHandler_WithClosures
drop_closures_ClientTypeHandler :: ClientTypeHandler -> ClientTypeHandler_WithClosures
drop_closures_ClientTypeHandler _f :: ClientTypeHandler
_f newitem :: Menuitem
newitem parent :: Menuitem
parent client :: Client
client _ = ClientTypeHandler
_f Menuitem
newitem Menuitem
parent Client
client
genClosure_ClientTypeHandler :: MonadIO m => ClientTypeHandler -> m (GClosure C_ClientTypeHandler)
genClosure_ClientTypeHandler :: ClientTypeHandler -> m (GClosure C_ClientTypeHandler)
genClosure_ClientTypeHandler cb :: ClientTypeHandler
cb = IO (GClosure C_ClientTypeHandler)
-> m (GClosure C_ClientTypeHandler)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ClientTypeHandler)
-> m (GClosure C_ClientTypeHandler))
-> IO (GClosure C_ClientTypeHandler)
-> m (GClosure C_ClientTypeHandler)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: ClientTypeHandler_WithClosures
cb' = ClientTypeHandler -> ClientTypeHandler_WithClosures
drop_closures_ClientTypeHandler ClientTypeHandler
cb
let cb'' :: C_ClientTypeHandler
cb'' = Maybe (Ptr (FunPtr C_ClientTypeHandler))
-> ClientTypeHandler_WithClosures -> C_ClientTypeHandler
wrap_ClientTypeHandler Maybe (Ptr (FunPtr C_ClientTypeHandler))
forall a. Maybe a
Nothing ClientTypeHandler_WithClosures
cb'
C_ClientTypeHandler -> IO (FunPtr C_ClientTypeHandler)
mk_ClientTypeHandler C_ClientTypeHandler
cb'' IO (FunPtr C_ClientTypeHandler)
-> (FunPtr C_ClientTypeHandler
-> IO (GClosure C_ClientTypeHandler))
-> IO (GClosure C_ClientTypeHandler)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClientTypeHandler -> IO (GClosure C_ClientTypeHandler)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ClientTypeHandler ::
Maybe (Ptr (FunPtr C_ClientTypeHandler)) ->
ClientTypeHandler_WithClosures ->
C_ClientTypeHandler
wrap_ClientTypeHandler :: Maybe (Ptr (FunPtr C_ClientTypeHandler))
-> ClientTypeHandler_WithClosures -> C_ClientTypeHandler
wrap_ClientTypeHandler funptrptr :: Maybe (Ptr (FunPtr C_ClientTypeHandler))
funptrptr _cb :: ClientTypeHandler_WithClosures
_cb newitem :: Ptr Menuitem
newitem parent :: Ptr Menuitem
parent client :: Ptr Client
client userData :: Ptr ()
userData = do
Menuitem
newitem' <- ((ManagedPtr Menuitem -> Menuitem) -> Ptr Menuitem -> IO Menuitem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Menuitem -> Menuitem
Dbusmenu.Menuitem.Menuitem) Ptr Menuitem
newitem
Menuitem
parent' <- ((ManagedPtr Menuitem -> Menuitem) -> Ptr Menuitem -> IO Menuitem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Menuitem -> Menuitem
Dbusmenu.Menuitem.Menuitem) Ptr Menuitem
parent
Client
client' <- ((ManagedPtr Client -> Client) -> Ptr Client -> IO Client
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Client -> Client
Dbusmenu.Client.Client) Ptr Client
client
Bool
result <- ClientTypeHandler_WithClosures
_cb Menuitem
newitem' Menuitem
parent' Client
client' Ptr ()
userData
Maybe (Ptr (FunPtr C_ClientTypeHandler)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ClientTypeHandler))
funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'