¿Cómo elegir el tipo de Haskell C correcto?

Question

He estudiado el lenguaje de programación Haskell y ahora descubrí que es posible llamar a las funciones de Haskell desde los programas C. Durante mis estudios en Haskell, creé un contador de frecuencia de palabras con Haskell y me gustaría intentar llamar a esa función desde un programa en C, pero no sé cómo hacerlo. He encontrado estos dos sitios web en haskell.org:

Calling Haskell from C

Foreign C types (Haskell module)

A pesar de eso, estoy un poco perdido los tipos de usar. Mis programas haskell es una lista de las siguientes funciones:

putStr. unlines. mapa testF. sortedTree

donde mis propias funciones

• testF es el tipo de testF :: Show a => ([Char], a) -> [Char]
• sortedTree es el tipo de sortedTree :: (Num a, Ord a) => [Char] -> [([Char], a)]

Estoy bastante seguro de que necesito convertir los tipos de cada función a tipos C, en lugar de convertir solo la función que llama a la tubería. El tipo de la función "principal" es

fileFreq :: [Char] -> IO()

Además de todo esto, estoy usando un árbol binario Haskell, que no es el tipo preludio.

Aquí es todo el código Haskell:

module WordCounter where 

import List 
import Char 
import Foreign.C.Types 

data BTree a = Tip | BNode a (BTree a) (BTree a) deriving Show 

insertFreq x Tip = BNode (x,1) Tip Tip 
insertFreq x (BNode (q,p) l r) | (map toLower x)==(map toLower q) = BNode (q, p+1) l r 
       | otherwise     = BNode (q,p) l (insertFreq x r) 

tlist :: BTree a -> [a] 
tlist Tip = [] 
tlist (BNode x l r) = concat [tlist l, [x], tlist r] 

sortedTree x = sortBy (\(x,y) (p,q) -> compare q y) (tlist (foldr insertFreq Tip (words x))) 

testF (x, n) = concat (x : ":" : " \t\t\t " : show n : []) 

concord = putStr . unlines . map testF . sortedTree 

fileFreq filename = do { text <- readFile filename; concord text } 

Puede alguien guiarme un poco con esto?

Answer 1

Lo que tendrá que hacer es crear funciones de envoltura para las funciones que necesita exponer a C y hacer el trabajo de convertir de tipos C a tipos de haskell.

También necesitará habilitar la extensión ForeignFunctionInterface, también cualquier excepción que pueda ocurrir en el código haskell debe manejarse en las funciones del contenedor.

Por ejemplo, si sólo necesita exponer su función fileFreq de nivel superior para C Se podría añadir una función como:

fileFreq_hs :: CString -> IO CInt 
fileFreq_hs cstr = catch (wrap_fileFreq cstr) (\_ -> return (-1)) 
    where wrap_fileFreq = do 
      str <- peekCString cstr 
      fileFreq str 
      return 0 

para crear una función que reúne un C-secuencia en una cadena de Haskell (utilizando funciones de Foreign.C.String), llama a su función fileFreq y traduce excepciones a C códigos de error (-1 si ocurrió una excepción, 0 en caso contrario).

Luego hay que exportarlo usando

foreign export ccall fileFreq_hs :: CString -> IO CInt 

y por supuesto es necesario agregar:

{-# LANGUAGE ForeignFunctionInterface #-} 

en la parte superior de su módulo.

Luego puede seguir las instrucciones en los enlaces que proporcionó para compilar esto en un C-stub y un archivo de encabezado y crear un archivo C que puede compilar con ghc.

Por supuesto, es posible ajustar cualquier función que tenga, solo necesita asegurarse de manejar posibles excepciones y organizar entre tipos C y tipos de Haskell.

El código completo con mis modificaciones es:

{-# LANGUAGE ForeignFunctionInterface #-} 
module WordCounter where 

import List 
import Char 
import Foreign.C.Types 
import Foreign.C.String 
import Control.Monad 

data BTree a = Tip | BNode a (BTree a) (BTree a) deriving Show 

insertFreq x Tip = BNode (x,1) Tip Tip 
insertFreq x (BNode (q,p) l r) | (map toLower x)==(map toLower q) = BNode (q, p+1) l r 
       | otherwise     = BNode (q,p) l (insertFreq x r) 

tlist :: BTree a -> [a] 
tlist Tip = [] 
tlist (BNode x l r) = concat [tlist l, [x], tlist r] 

sortedTree :: (Ord t, Num t) => String -> [([Char], t)] 
sortedTree x = sortBy (\(x,y) (p,q) -> compare q y) (tlist (foldr insertFreq Tip (words x))) 

testF :: (Show t) => ([Char], t) -> [Char] 
testF (x, n) = concat (x : ":" : " \t\t\t " : show n : []) 

concord = putStr . unlines . map testF . sortedTree 

fileFreq filename = do { text <- readFile filename; concord text } 

fileFreq_hs :: CString -> IO CInt 
fileFreq_hs cstr = catch (wrap_fileFreq cstr) (\_ -> return (-1)) 
    where wrap_fileFreq cstr = do 
      str <- peekCString cstr 
      fileFreq str 
      return 0 
foreign export ccall fileFreq_hs :: CString -> IO CInt