GI.Dazzle.Callbacks

Signals

CounterForeachFunc

type C_CounterForeachFunc = Ptr Counter -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type CounterForeachFunc

Arguments

 = Counter

counter: the counter.

-> IO ()

Function prototype for callbacks provided to counterArenaForeach.

type CounterForeachFunc_WithClosures

Arguments

 = Counter

counter: the counter.

-> Ptr ()

userData: data supplied to counterArenaForeach.

-> IO ()

Function prototype for callbacks provided to counterArenaForeach.

drop_closures_CounterForeachFunc :: CounterForeachFunc -> CounterForeachFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_CounterForeachFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_CounterForeachFunc

-> Counter

counter: the counter.

-> Ptr ()

userData: data supplied to counterArenaForeach.

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_CounterForeachFunc :: MonadIO m => CounterForeachFunc -> m (GClosure C_CounterForeachFunc)

Wrap the callback into a GClosure.

mk_CounterForeachFunc :: C_CounterForeachFunc -> IO (FunPtr C_CounterForeachFunc)

Generate a function pointer callable from C code, from a C_CounterForeachFunc.

noCounterForeachFunc :: Maybe CounterForeachFunc

A convenience synonym for Nothing :: Maybe CounterForeachFunc.

noCounterForeachFunc_WithClosures :: Maybe CounterForeachFunc_WithClosures

A convenience synonym for Nothing :: Maybe CounterForeachFunc_WithClosures.

wrap_CounterForeachFunc :: Maybe (Ptr (FunPtr C_CounterForeachFunc)) -> CounterForeachFunc_WithClosures -> C_CounterForeachFunc

Wrap a CounterForeachFunc into a C_CounterForeachFunc.

DirectoryModelVisibleFunc

type C_DirectoryModelVisibleFunc = Ptr DirectoryModel -> Ptr File -> Ptr FileInfo -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type DirectoryModelVisibleFunc = DirectoryModel -> File -> FileInfo -> IO Bool

No description available in the introspection data.

type DirectoryModelVisibleFunc_WithClosures = DirectoryModel -> File -> FileInfo -> Ptr () -> IO Bool

No description available in the introspection data.

drop_closures_DirectoryModelVisibleFunc :: DirectoryModelVisibleFunc -> DirectoryModelVisibleFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_DirectoryModelVisibleFunc :: (HasCallStack, MonadIO m, IsDirectoryModel a, IsFile b, IsFileInfo c) => FunPtr C_DirectoryModelVisibleFunc -> a -> b -> c -> Ptr () -> m Bool

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_DirectoryModelVisibleFunc :: MonadIO m => DirectoryModelVisibleFunc -> m (GClosure C_DirectoryModelVisibleFunc)

Wrap the callback into a GClosure.

mk_DirectoryModelVisibleFunc :: C_DirectoryModelVisibleFunc -> IO (FunPtr C_DirectoryModelVisibleFunc)

Generate a function pointer callable from C code, from a C_DirectoryModelVisibleFunc.

noDirectoryModelVisibleFunc :: Maybe DirectoryModelVisibleFunc

A convenience synonym for Nothing :: Maybe DirectoryModelVisibleFunc.

noDirectoryModelVisibleFunc_WithClosures :: Maybe DirectoryModelVisibleFunc_WithClosures

A convenience synonym for Nothing :: Maybe DirectoryModelVisibleFunc_WithClosures.

wrap_DirectoryModelVisibleFunc :: Maybe (Ptr (FunPtr C_DirectoryModelVisibleFunc)) -> DirectoryModelVisibleFunc_WithClosures -> C_DirectoryModelVisibleFunc

Wrap a DirectoryModelVisibleFunc into a C_DirectoryModelVisibleFunc.

ListModelFilterFunc

type C_ListModelFilterFunc = Ptr Object -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type ListModelFilterFunc = Object -> IO Bool

No description available in the introspection data.

type ListModelFilterFunc_WithClosures = Object -> Ptr () -> IO Bool

No description available in the introspection data.

drop_closures_ListModelFilterFunc :: ListModelFilterFunc -> ListModelFilterFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ListModelFilterFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ListModelFilterFunc -> a -> Ptr () -> m Bool

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ListModelFilterFunc :: MonadIO m => ListModelFilterFunc -> m (GClosure C_ListModelFilterFunc)

Wrap the callback into a GClosure.

mk_ListModelFilterFunc :: C_ListModelFilterFunc -> IO (FunPtr C_ListModelFilterFunc)

Generate a function pointer callable from C code, from a C_ListModelFilterFunc.

noListModelFilterFunc :: Maybe ListModelFilterFunc

A convenience synonym for Nothing :: Maybe ListModelFilterFunc.

noListModelFilterFunc_WithClosures :: Maybe ListModelFilterFunc_WithClosures

A convenience synonym for Nothing :: Maybe ListModelFilterFunc_WithClosures.

wrap_ListModelFilterFunc :: Maybe (Ptr (FunPtr C_ListModelFilterFunc)) -> ListModelFilterFunc_WithClosures -> C_ListModelFilterFunc

Wrap a ListModelFilterFunc into a C_ListModelFilterFunc.

RecursiveIgnoreFunc

type C_RecursiveIgnoreFunc = Ptr File -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type RecursiveIgnoreFunc = File -> IO Bool

No description available in the introspection data.

type RecursiveIgnoreFunc_WithClosures = File -> Ptr () -> IO Bool

No description available in the introspection data.

drop_closures_RecursiveIgnoreFunc :: RecursiveIgnoreFunc -> RecursiveIgnoreFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_RecursiveIgnoreFunc :: (HasCallStack, MonadIO m, IsFile a) => FunPtr C_RecursiveIgnoreFunc -> a -> Ptr () -> m Bool

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_RecursiveIgnoreFunc :: MonadIO m => RecursiveIgnoreFunc -> m (GClosure C_RecursiveIgnoreFunc)

Wrap the callback into a GClosure.

mk_RecursiveIgnoreFunc :: C_RecursiveIgnoreFunc -> IO (FunPtr C_RecursiveIgnoreFunc)

Generate a function pointer callable from C code, from a C_RecursiveIgnoreFunc.

noRecursiveIgnoreFunc :: Maybe RecursiveIgnoreFunc

A convenience synonym for Nothing :: Maybe RecursiveIgnoreFunc.

noRecursiveIgnoreFunc_WithClosures :: Maybe RecursiveIgnoreFunc_WithClosures

A convenience synonym for Nothing :: Maybe RecursiveIgnoreFunc_WithClosures.

wrap_RecursiveIgnoreFunc :: Maybe (Ptr (FunPtr C_RecursiveIgnoreFunc)) -> RecursiveIgnoreFunc_WithClosures -> C_RecursiveIgnoreFunc

Wrap a RecursiveIgnoreFunc into a C_RecursiveIgnoreFunc.

ShortcutChordTableForeach

type C_ShortcutChordTableForeach = Ptr ShortcutChord -> Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type ShortcutChordTableForeach = ShortcutChord -> Ptr () -> IO ()

No description available in the introspection data.

type ShortcutChordTableForeach_WithClosures = ShortcutChord -> Ptr () -> Ptr () -> IO ()

No description available in the introspection data.

drop_closures_ShortcutChordTableForeach :: ShortcutChordTableForeach -> ShortcutChordTableForeach_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ShortcutChordTableForeach :: (HasCallStack, MonadIO m) => FunPtr C_ShortcutChordTableForeach -> ShortcutChord -> Ptr () -> Ptr () -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ShortcutChordTableForeach :: MonadIO m => ShortcutChordTableForeach -> m (GClosure C_ShortcutChordTableForeach)

Wrap the callback into a GClosure.

mk_ShortcutChordTableForeach :: C_ShortcutChordTableForeach -> IO (FunPtr C_ShortcutChordTableForeach)

Generate a function pointer callable from C code, from a C_ShortcutChordTableForeach.

noShortcutChordTableForeach :: Maybe ShortcutChordTableForeach

A convenience synonym for Nothing :: Maybe ShortcutChordTableForeach.

noShortcutChordTableForeach_WithClosures :: Maybe ShortcutChordTableForeach_WithClosures

A convenience synonym for Nothing :: Maybe ShortcutChordTableForeach_WithClosures.

wrap_ShortcutChordTableForeach :: Maybe (Ptr (FunPtr C_ShortcutChordTableForeach)) -> ShortcutChordTableForeach_WithClosures -> C_ShortcutChordTableForeach

Wrap a ShortcutChordTableForeach into a C_ShortcutChordTableForeach.

StackListCreateWidgetFunc

type C_StackListCreateWidgetFunc = Ptr Object -> Ptr () -> IO (Ptr Widget)

Type for the callback on the (unwrapped) C side.

type StackListCreateWidgetFunc

Arguments

 = Object

item: the item from the model for which to create a widget for

-> IO Widget

Returns: a Widget that represents item

Called for stack lists that are bound to a ListModel with stackListPush for each item that gets added to the model.

type StackListCreateWidgetFunc_WithClosures

Arguments

 = Object

item: the item from the model for which to create a widget for

-> Ptr ()

userData: user data from stackListPush

-> IO Widget

Returns: a Widget that represents item

Called for stack lists that are bound to a ListModel with stackListPush for each item that gets added to the model.

drop_closures_StackListCreateWidgetFunc :: StackListCreateWidgetFunc -> StackListCreateWidgetFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_StackListCreateWidgetFunc

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_StackListCreateWidgetFunc

-> a

item: the item from the model for which to create a widget for

-> Ptr ()

userData: user data from stackListPush

-> m Widget

Returns: a Widget that represents item

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_StackListCreateWidgetFunc :: MonadIO m => StackListCreateWidgetFunc -> m (GClosure C_StackListCreateWidgetFunc)

Wrap the callback into a GClosure.

mk_StackListCreateWidgetFunc :: C_StackListCreateWidgetFunc -> IO (FunPtr C_StackListCreateWidgetFunc)

Generate a function pointer callable from C code, from a C_StackListCreateWidgetFunc.

noStackListCreateWidgetFunc :: Maybe StackListCreateWidgetFunc

A convenience synonym for Nothing :: Maybe StackListCreateWidgetFunc.

noStackListCreateWidgetFunc_WithClosures :: Maybe StackListCreateWidgetFunc_WithClosures

A convenience synonym for Nothing :: Maybe StackListCreateWidgetFunc_WithClosures.

wrap_StackListCreateWidgetFunc :: Maybe (Ptr (FunPtr C_StackListCreateWidgetFunc)) -> StackListCreateWidgetFunc_WithClosures -> C_StackListCreateWidgetFunc

Wrap a StackListCreateWidgetFunc into a C_StackListCreateWidgetFunc.

SuggestionPositionFunc

type C_SuggestionPositionFunc = Ptr SuggestionEntry -> Ptr Rectangle -> Ptr CInt -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type SuggestionPositionFunc

Arguments

 = SuggestionEntry

entry: a SuggestionEntry

-> Rectangle

area: location to place the popover

-> Bool

isAbsolute: If the area is in absolute coordinates

-> IO Bool

Positions the popover in the coordinates defined by area.

If isAbsolute is set to True, then absolute coordinates are used. Otherwise, the position is expected to be relative to entry.

Since: 3.26

type SuggestionPositionFunc_WithClosures

Arguments

 = SuggestionEntry

entry: a SuggestionEntry

-> Rectangle

area: location to place the popover

-> Bool

isAbsolute: If the area is in absolute coordinates

-> Ptr ()

userData: closure data

-> IO Bool

Positions the popover in the coordinates defined by area.

If isAbsolute is set to True, then absolute coordinates are used. Otherwise, the position is expected to be relative to entry.

Since: 3.26

drop_closures_SuggestionPositionFunc :: SuggestionPositionFunc -> SuggestionPositionFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_SuggestionPositionFunc

Arguments

:: (HasCallStack, MonadIO m, IsSuggestionEntry a)

=> FunPtr C_SuggestionPositionFunc

-> a

entry: a SuggestionEntry

-> Rectangle

area: location to place the popover

-> Bool

isAbsolute: If the area is in absolute coordinates

-> Ptr ()

userData: closure data

-> m Bool

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_SuggestionPositionFunc :: MonadIO m => SuggestionPositionFunc -> m (GClosure C_SuggestionPositionFunc)

Wrap the callback into a GClosure.

mk_SuggestionPositionFunc :: C_SuggestionPositionFunc -> IO (FunPtr C_SuggestionPositionFunc)

Generate a function pointer callable from C code, from a C_SuggestionPositionFunc.

noSuggestionPositionFunc :: Maybe SuggestionPositionFunc

A convenience synonym for Nothing :: Maybe SuggestionPositionFunc.

noSuggestionPositionFunc_WithClosures :: Maybe SuggestionPositionFunc_WithClosures

A convenience synonym for Nothing :: Maybe SuggestionPositionFunc_WithClosures.

wrap_SuggestionPositionFunc :: Maybe (Ptr (FunPtr C_SuggestionPositionFunc)) -> SuggestionPositionFunc_WithClosures -> C_SuggestionPositionFunc

Wrap a SuggestionPositionFunc into a C_SuggestionPositionFunc.

TaskCacheCallback

type C_TaskCacheCallback = Ptr TaskCache -> Ptr () -> Ptr Task -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type TaskCacheCallback

Arguments

 = TaskCache

self: An TaskCache.

-> Ptr ()

key: the key to fetch

-> Task

task: the task to be completed

-> IO ()

TaskCacheCallback is the prototype for a function to be executed to populate an item in the cache.

This function will be executed when a fault (cache miss) occurs from a caller requesting an item from the cache.

The callee may complete the operation asynchronously, but MUST return either a GObject using taskReturnPointer or a GError using taskReturnError or g_task_return_new_error().

type TaskCacheCallback_WithClosures

Arguments

 = TaskCache

self: An TaskCache.

-> Ptr ()

key: the key to fetch

-> Task

task: the task to be completed

-> Ptr ()

userData: user_data registered at initialization.

-> IO ()

TaskCacheCallback is the prototype for a function to be executed to populate an item in the cache.

This function will be executed when a fault (cache miss) occurs from a caller requesting an item from the cache.

The callee may complete the operation asynchronously, but MUST return either a GObject using taskReturnPointer or a GError using taskReturnError or g_task_return_new_error().

drop_closures_TaskCacheCallback :: TaskCacheCallback -> TaskCacheCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TaskCacheCallback

Arguments

:: (HasCallStack, MonadIO m, IsTaskCache a, IsTask b)

=> FunPtr C_TaskCacheCallback

-> a

self: An TaskCache.

-> Ptr ()

key: the key to fetch

-> b

task: the task to be completed

-> Ptr ()

userData: user_data registered at initialization.

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TaskCacheCallback :: MonadIO m => TaskCacheCallback -> m (GClosure C_TaskCacheCallback)

Wrap the callback into a GClosure.

mk_TaskCacheCallback :: C_TaskCacheCallback -> IO (FunPtr C_TaskCacheCallback)

Generate a function pointer callable from C code, from a C_TaskCacheCallback.

noTaskCacheCallback :: Maybe TaskCacheCallback

A convenience synonym for Nothing :: Maybe TaskCacheCallback.

noTaskCacheCallback_WithClosures :: Maybe TaskCacheCallback_WithClosures

A convenience synonym for Nothing :: Maybe TaskCacheCallback_WithClosures.

wrap_TaskCacheCallback :: Maybe (Ptr (FunPtr C_TaskCacheCallback)) -> TaskCacheCallback_WithClosures -> C_TaskCacheCallback

Wrap a TaskCacheCallback into a C_TaskCacheCallback.

TreeFilterFunc

type C_TreeFilterFunc = Ptr Tree -> Ptr TreeNode -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type TreeFilterFunc

Arguments

 = Tree

-> TreeNode

-> IO Bool

Returns: True if node should be visible.

Callback to check if node should be visible.

type TreeFilterFunc_WithClosures

Arguments

 = Tree

-> TreeNode

-> Ptr ()

-> IO Bool

Returns: True if node should be visible.

Callback to check if node should be visible.

drop_closures_TreeFilterFunc :: TreeFilterFunc -> TreeFilterFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeFilterFunc

Arguments

:: (HasCallStack, MonadIO m, IsTree a, IsTreeNode b)

=> FunPtr C_TreeFilterFunc

-> a

-> b

-> Ptr ()

-> m Bool

Returns: True if node should be visible.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TreeFilterFunc :: MonadIO m => TreeFilterFunc -> m (GClosure C_TreeFilterFunc)

Wrap the callback into a GClosure.

mk_TreeFilterFunc :: C_TreeFilterFunc -> IO (FunPtr C_TreeFilterFunc)

Generate a function pointer callable from C code, from a C_TreeFilterFunc.

noTreeFilterFunc :: Maybe TreeFilterFunc

A convenience synonym for Nothing :: Maybe TreeFilterFunc.

noTreeFilterFunc_WithClosures :: Maybe TreeFilterFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeFilterFunc_WithClosures.

wrap_TreeFilterFunc :: Maybe (Ptr (FunPtr C_TreeFilterFunc)) -> TreeFilterFunc_WithClosures -> C_TreeFilterFunc

Wrap a TreeFilterFunc into a C_TreeFilterFunc.

TreeFindFunc

type C_TreeFindFunc = Ptr Tree -> Ptr TreeNode -> Ptr TreeNode -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type TreeFindFunc

Arguments

 = Tree

-> TreeNode

-> TreeNode

-> IO Bool

Returns: True if child matched

Callback to check child, a child of node, matches a lookup request. Returns True if child matches, False if not.

type TreeFindFunc_WithClosures

Arguments

 = Tree

-> TreeNode

-> TreeNode

-> Ptr ()

-> IO Bool

Returns: True if child matched

Callback to check child, a child of node, matches a lookup request. Returns True if child matches, False if not.

drop_closures_TreeFindFunc :: TreeFindFunc -> TreeFindFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeFindFunc

Arguments

:: (HasCallStack, MonadIO m, IsTree a, IsTreeNode b, IsTreeNode c)

=> FunPtr C_TreeFindFunc

-> a

-> b

-> c

-> Ptr ()

-> m Bool

Returns: True if child matched

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TreeFindFunc :: MonadIO m => TreeFindFunc -> m (GClosure C_TreeFindFunc)

Wrap the callback into a GClosure.

mk_TreeFindFunc :: C_TreeFindFunc -> IO (FunPtr C_TreeFindFunc)

Generate a function pointer callable from C code, from a C_TreeFindFunc.

noTreeFindFunc :: Maybe TreeFindFunc

A convenience synonym for Nothing :: Maybe TreeFindFunc.

noTreeFindFunc_WithClosures :: Maybe TreeFindFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeFindFunc_WithClosures.

wrap_TreeFindFunc :: Maybe (Ptr (FunPtr C_TreeFindFunc)) -> TreeFindFunc_WithClosures -> C_TreeFindFunc

Wrap a TreeFindFunc into a C_TreeFindFunc.

TreeNodeCompareFunc

type C_TreeNodeCompareFunc = Ptr TreeNode -> Ptr TreeNode -> Ptr () -> IO Int32

Type for the callback on the (unwrapped) C side.

type TreeNodeCompareFunc = TreeNode -> TreeNode -> IO Int32

No description available in the introspection data.

type TreeNodeCompareFunc_WithClosures = TreeNode -> TreeNode -> Ptr () -> IO Int32

No description available in the introspection data.

drop_closures_TreeNodeCompareFunc :: TreeNodeCompareFunc -> TreeNodeCompareFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TreeNodeCompareFunc :: (HasCallStack, MonadIO m, IsTreeNode a, IsTreeNode b) => FunPtr C_TreeNodeCompareFunc -> a -> b -> Ptr () -> m Int32

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TreeNodeCompareFunc :: MonadIO m => TreeNodeCompareFunc -> m (GClosure C_TreeNodeCompareFunc)

Wrap the callback into a GClosure.

mk_TreeNodeCompareFunc :: C_TreeNodeCompareFunc -> IO (FunPtr C_TreeNodeCompareFunc)

Generate a function pointer callable from C code, from a C_TreeNodeCompareFunc.

noTreeNodeCompareFunc :: Maybe TreeNodeCompareFunc

A convenience synonym for Nothing :: Maybe TreeNodeCompareFunc.

noTreeNodeCompareFunc_WithClosures :: Maybe TreeNodeCompareFunc_WithClosures

A convenience synonym for Nothing :: Maybe TreeNodeCompareFunc_WithClosures.

wrap_TreeNodeCompareFunc :: Maybe (Ptr (FunPtr C_TreeNodeCompareFunc)) -> TreeNodeCompareFunc_WithClosures -> C_TreeNodeCompareFunc

Wrap a TreeNodeCompareFunc into a C_TreeNodeCompareFunc.

TrieTraverseFunc

type C_TrieTraverseFunc = Ptr Trie -> CString -> Ptr () -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type TrieTraverseFunc = Trie -> Text -> Ptr () -> IO Bool

No description available in the introspection data.

type TrieTraverseFunc_WithClosures = Trie -> Text -> Ptr () -> Ptr () -> IO Bool

No description available in the introspection data.

drop_closures_TrieTraverseFunc :: TrieTraverseFunc -> TrieTraverseFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TrieTraverseFunc :: (HasCallStack, MonadIO m) => FunPtr C_TrieTraverseFunc -> Trie -> Text -> Ptr () -> Ptr () -> m Bool

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TrieTraverseFunc :: MonadIO m => TrieTraverseFunc -> m (GClosure C_TrieTraverseFunc)

Wrap the callback into a GClosure.

mk_TrieTraverseFunc :: C_TrieTraverseFunc -> IO (FunPtr C_TrieTraverseFunc)

Generate a function pointer callable from C code, from a C_TrieTraverseFunc.

noTrieTraverseFunc :: Maybe TrieTraverseFunc

A convenience synonym for Nothing :: Maybe TrieTraverseFunc.

noTrieTraverseFunc_WithClosures :: Maybe TrieTraverseFunc_WithClosures

A convenience synonym for Nothing :: Maybe TrieTraverseFunc_WithClosures.

wrap_TrieTraverseFunc :: Maybe (Ptr (FunPtr C_TrieTraverseFunc)) -> TrieTraverseFunc_WithClosures -> C_TrieTraverseFunc

Wrap a TrieTraverseFunc into a C_TrieTraverseFunc.