Chiamare una funzione alla cancellazione dell'oggetto in Haskell

Question

Sto scrivendo un wrapper Haskell per una classe C++. Ho deciso di rappresentarlo come una struttura dati Haskell contenente un puntatore (Foreign.Ptr) all'istanza della classe in C++. Qualcosa del genere.

In C++:

class MyClass { 
public: 
    double my_method(); 

    // ... 
}; 

extern "C" MyClass* cpp_new_MyClass() { 
    return new MyClass(); 
} 

extern "C" double cpp_my_method(MyClass *obj) { 
    return obj->my_method(); 
} 

In Haskell:

Data MyClass = MyClass (Ptr()) 

foreign import ccall "cpp_new_MyClass" cppNewMyClass :: Ptr() 
foreign import ccall "cpp_my_method" cppMyMethod :: Ptr() -> Double 

mkMyClass :: MyClass 
mkMyClass = MyClass cppNewMyClass 

myMethod :: MyClass -> Double 
myMethod (MyClass ptr) = cppMyMethod ptr 

Il problema è, non so come implementare correttamente MyClass eliminazione. Ad un certo punto, Garbage Collector Haskell cancellerà l'oggetto MyClass, ma non attiverà la memoria MyClass * liberando in C++. Come lo aggiusto?

Sono consapevole di ForeignPtr, ma utilizza IO Monade, che non è soddisfacente perché voglio la struttura di dati avvolto a comportarsi esattamente come un normale struttura dati Haskell, senza la necessità di ripartisce esplicito/liberare memoria o IO monadi .

Answer 1

“ utilizza IO Monade, che non è soddisfacente perché voglio la struttura di dati avvolto a comportarsi esattamente come un normale struttura di dati Haskell ”

Certo che lo sai, ma purtroppo non è davvero possibile. Le funzioni estere “ ” possono sempre fare cose divertenti che non dovrebbero essere possibili in Haskell; il sistema di tipi non ha modo di guardare lì e prevenirlo.

Questo dilemma è l'unico (!) Motivo per cui abbiamo unsafePerformIO, e in effetti il ​​tuo è un buon esempio di un'applicazione valida per quella cosa.

che non ho ancora fatto questo io stesso, ma il vostro codice dovrebbe essere simile al seguente:

extern "C" void cpp_delete_MyClass(MyClass* obj) { 
    delete obj; 
} 

foreign import ccall "cpp_new_MyClass" cppNewMyClass :: IO (Ptr()) 
foreign import ccall "&cpp_delete_MyClass" cppDeleteMyClass :: FunPtr (Ptr() -> IO()) 

data MyClass = MyClass (ForeignPtr()) 

mkMyClass :: MyClass 
mkMyClass = unsafePerformIO $ do 
    newObj <- cppNewMyClass 
    fPtr <- newForeignPtr cppDeleteMyClass newObj 
    return $ MyClass fptr 

io non sono molto sicuro di quei FunPtr s, si spera che qualcuno commenterà qualcosa su che ...