The major piece missing from the FFI library is the high-level marshalling support. Moreover, `MarshalUtils' isn't quite there. In fact, I think, we should have a family of MarshalXXX modules, which include what currently is in MarshalUtils plus some more stuff. MarshalUtils ~~~~~~~~~~~~ The reason that I don't like MarshalUtils as it is are the following: (1) It isn't H98 and in fact its interface cannot be implemented with H98[1]. The problem are the routines with signatures in patterns: malloc :: Storable a => IO (Ptr a) malloc :: IO (Ptr a) = mallocBytes (sizeOf (undefined::a)) alloca :: Storable a => (Ptr a -> IO b) -> IO b alloca (act :: Ptr a -> IO b) = allocaBytes (sizeOf (undefined::a)) act <etc> (2) pokeArray, peekArray, etc are really part of what should go into the high-level marshalling. Point (2) is easily resolved by defining a family of modules including all the necessary functionality. However, Point (1) is a problem. First of all, I guess, we have to revert to the signature for allocation that I originally used in the C2HS library: malloc :: Storable a => a -> IO Addr malloc dummy = mallocBytes (sizeOf dummy) All the other allocation routines have to be altered in a similar way. A similar problem arises for copyArray and moveArray, where I guess the additional argument is in practice more awkward as for the allocation routines. Finally, indexPtr is affected, which is especially annoying since it can't be used infix anymore after the change. The Marshal modules ~~~~~~~~~~~~~~~~~~~ I propose the following set of modules: - MarshalAlloc: The allocation routines that are in MarshalUtils now, but modified as outlined above. - MarshalArray: The array marshalling routines - MarshalString: Most people seem to be of the opinion that we have to handle strings specially due to Unicode conversion requirements. So, this is were string marshalling goes. - MarshalError: Combinators to test for common error conditions. The main open problem here is the handling of errno, I think. - MarshalConv: The C2HS IntConv, BoolConv, etc classes. Marcin just uses `fromIntegral' here, but I think that this is too limited - eg, it doesn't handle Bool. Moreover, soemthing along the C2HS ToAddr/FromAddr classes, but it probably makes to have `stdArrayPtr' etc as additional member functions (this is similar to the newXXX routines that are in MarshalUtils now, but with additional overloading). Furthermore, Marcin-syle withXXX routines would fo here. - MarshalUtils: The memcpy/memmove stuff, indexPtr (if it still makes sense), and whatever else doesn't get its own module. I think, we should leave C2HS's marshX routines out. We discussed how to make them arity independent for quite a while and AFAIR, there wasn't a really good proposal. Finally, all the above modules should be jointly exported by a module `Marshal'. Comments? Cheers, Manuel [1] Which unfortunately escaped me when we discussed MarshalUtils for the first time.