Eu tenho uma função C que se parece com isto:
/**
* @n the outer dimension of data
* @lengths the length of each "row" of data
* @data the data itself
*/
double foo(int n, int* lengths, double** data);
Gostaria de chamar essa função de Haskell, mas não tenho certeza da melhor forma de lidar com a alocação das matrizes internas do data
ponteiro. Em essência, tenho algo assim:
foreign import ccall "foo.h foo"
c_foo :: CInt -> Ptr CInt -> Ptr (Ptr CDouble) -> CDouble
haskFoo :: Int -> [Int] -> [[Double]] -> Double
haskFoo :: n lengths data = unsafePerformIO $
allocaArray n $ \lengths_ptr -> do
pokeArray lengths_ptr (map fromIntegral lengths)
allocaArray n $ \data_outer_ptrs -> do
-- TODO alloc inner arrays
x <- c_foo (fromIntegral n) lengths_ptr data_outer_ptrs
return realToFrac x
Idealmente, eu usaria algo parecido allocaArray
ou withStorableArray
(como na resposta aqui ), mas não sei como fazer isso com um número de lambdas aninhados em tempo de execução. Acho que posso conseguir o que quero, mallocArray
mas prefiro usar algo no estilo alloca
que garanta a limpeza da memória alocada.