Static non-exported stubs?

[Lauri Alanko]

Hello.

I'm having a minor annoyance with the FFI, and was wondering if there
was a better solution available.

> {-# LANGUAGE ForeignFunctionInterface #-}
> module FFITest where
> import Foreign

Suppose we are interfacing with a foreign library that uses callbacks,
for instance, suppose we have "void register_callback(void  
(*callback)(void));"

> foreign import ccall "register_callback"
>  registerCallback :: FunPtr (IO ()) -> IO ()

And we have a Haskell function that we want to register:

> myCallback :: IO ()
> myCallback = undefined

So how do we do this? The simplest option is to use a dynamic wrapper:

> foreign import ccall "wrapper"   wrapCallback :: IO () -> IO (FunPtr (IO ()))
>                      registerMy :: IO ()                 registerMy  
> = wrapCallback myCallback >>= registerCallback

However, this is not really ideal:

* We don't have a single global FunPtr, but we have to create a new one
as an IO action. If we do the registration many times, we end up
creating multiple wrappers for the same Haskell function, which is a bit
wasteful.

* Further, since the the FunPtr has been dynamically allocated, we have
to remember to ensure that freeHaskellFunPtr gets called when the
callback is no longer used.

* Finally, I'm rather uncomfortable with the deep, deep magic that
dynamic wrappers have to resort to to create new entry points at
runtime.

Since I'm registering a static top-level function, I shouldn't be having
any of these problems. And indeed, I can get a FunPtr for the
function... by exporting it first:

> foreign export ccall "my_callback" myCallback :: IO ()
> foreign import ccall "&my_callback" myCallbackPtr :: FunPtr (IO ())
>
> registerMy' :: IO ()
> registerMy' = registerCallback myCallbackPtr

So this works, but it's annoying. I need to write redundantly two almost
similar-looking foreign declarations, and this gives the impression of a
strange hack instead of a normal conversion. Worst of all, I'm forced to
pollute the symbol namespace by exporting my function as a symbol with
external linkage. But I don't need my callback to be visible as a symbol
to foreign code! I just need its address so I can pass it to the
registration function.

This is a very minor thing, but this seems like a very common use case
so it's strange that there doesn't seem to be direct support for it. Is
there really no way to tell the compiler to create a _static_ stub for a
Haskell function and return the address of that stub, but _not_ export
it as a symbol?

Thanks,


Lauri