Intercambio de datos estructurados entre Haskell y C

Recomiendo encarecidamente el uso de un preprocesador. Me gusta c2hs, pero hsc2hs es muy común porque está incluido con ghc. Greencard parece estar abandonada.

Para responder a sus preguntas:

1) Sí, a través de la definición de la instancia almacenable. El uso de Storable es el único mecanismo seguro para pasar datos a través de la FFI. La instancia almacenable define cómo ordenar los datos entre un tipo Haskell y la memoria raw (ya sea un Haskell Ptr, ForeignPtr, o StablePtr, o un C puntero). He aquí un ejemplo:

data PlateC = PlateC {
  numX :: Int,
  numY :: Int,
  v1   :: Double,
  v2   :: Double } deriving (Eq, Show)

instance Storable PlateC where
  alignment _ = alignment (undefined :: CDouble)
  sizeOf _ = {#sizeof PlateC#}
  peek p =
    PlateC <$> fmap fI ({#get PlateC.numX #} p)
           <*> fmap fI ({#get PlateC.numY #} p)
           <*> fmap realToFrac ({#get PlateC.v1 #} p)
           <*> fmap realToFrac ({#get PlateC.v2 #} p)
  poke p (PlateC xv yv v1v v2v) = do
    {#set PlateC.numX #} p (fI xv)
    {#set PlateC.numY #} p (fI yv)
    {#set PlateC.v1 #}   p (realToFrac v1v)
    {#set PlateC.v2 #}   p (realToFrac v2v)

Los fragmentos {# ... #} son código c2hs. fI es fromIntegral. Los valores de los fragmentos get y set se refieren a la siguiente estructura de un encabezado incluido, no al tipo Haskell del mismo nombre:

struct PlateCTag ;

typedef struct PlateCTag {
  int numX;
  int numY;
  double v1;
  double v2;
} PlateC ;

C2hs convierte esto en el siguiente Haskell simple: {[17]]}

instance Storable PlateC where
  alignment _ = alignment (undefined :: CDouble)
  sizeOf _ = 24
  peek p =
    PlateC <$> fmap fI ((\ptr -> do {peekByteOff ptr 0 ::IO CInt}) p)
           <*> fmap fI ((\ptr -> do {peekByteOff ptr 4 ::IO CInt}) p)
           <*> fmap realToFrac ((\ptr -> do {peekByteOff ptr 8 ::IO CDouble}) p)
           <*> fmap realToFrac ((\ptr -> do {peekByteOff ptr 16 ::IO CDouble}) p)
  poke p (PlateC xv yv v1v v2v) = do
    (\ptr val -> do {pokeByteOff ptr 0 (val::CInt)}) p (fI xv)
    (\ptr val -> do {pokeByteOff ptr 4 (val::CInt)}) p (fI yv)
    (\ptr val -> do {pokeByteOff ptr 8 (val::CDouble)})   p (realToFrac v1v)
    (\ptr val -> do {pokeByteOff ptr 16 (val::CDouble)})   p (realToFrac v2v)

Por supuesto, las compensaciones dependen de la arquitectura, por lo que usar un preprocesador le permite escribir código portable.

Utiliza esto asignando espacio para sus datos tipo (new,malloc, etc.) and poke ing the data into the Ptr (or ForeignPtr).

2) Este es el diseño de memoria real.

3) Hay una pena por leer / escribir con peek/poke. Si tiene muchos datos, es mejor convertir solo lo que necesita, por ejemplo, leer solo un elemento de una matriz C en lugar de ordenar toda la matriz a una lista de Haskell.

4) La sintaxis depende del preprocesador que elija. c2hs docs. hsc2hs docs. Confusamente, hsc2hs usa la sintaxis #stuff o #{stuff}, mientras que c2hs usa {#stuff #}.

5) La sugerencia de @sclv es lo que yo también haría. Escriba una instancia almacenable y mantenga un puntero a los datos. Puede escribir funciones C para hacer todo el trabajo y llamarlas a través del FFI, o (menos bueno) escribir Haskell de bajo nivel usando peek y poke para operar solo en las partes de los datos que necesita. Ordenar todo el asunto de ida y vuelta (es decir, llamar a peek o poke en toda la estructura de datos) será caro, pero si solo pasa punteros alrededor del costo será mínimo.

Llamar a funciones importadas a través de la FFI tiene una penalización significativa a menos que estén marcadas como "inseguras". Declarar una importación "insegura" significa que la función no debe volver a llamar a Haskell o a resultados de comportamiento indefinido. Si está utilizando concurrencia o paralelismo, también significa que todos los subprocesos de Haskell en la misma capacidad (es decir, CPU) se bloquearán hasta que regrese la llamada, por lo que debería regresar bastante pronto. Si esas condiciones son aceptables, una llamada "insegura" es relativamente rápida.

Hay muchos paquetes en Hackage que tratan con este tipo de cosas. Puedo recomendar hsndfile y hCsound como buenas prácticas con c2hs. Probablemente sea más fácil si miras un enlace a una pequeña biblioteca de C con la que estés familiarizado.