At 2001-09-23 23:54, I wrote:
>As you point out, there are restrictions
>on just what existing C functions you can bind to. If your function looks
>like this:
>
> const char* foo (struct SomeLinkedList*);
>
>...you have no choice but to write 'impedance-matching' code for that
>function.
On second thought, I wonder if this is really true? It seems possible to
declare a "raw" import and then use Haskell to adapt:
foreign import "foo" raw_foo :: Ptr () -> IO (Ptr ());
foo :: Ptr SomeLinkedList -> IO (ConstPtr Char);
foo = importFunction raw_foo;
instance Storable SomeLinkedList where
{
...
};
Of course you'd need a suitable definition of importFunction:
class ConvertValueToRaw t r | t -> r where
{
importValue :: r -> t;
exportValue :: t -> r;
};
class ConvertFunctionToRaw t r | t -> r where
{
importFunction :: r -> t;
};
instance (ConvertValueToRaw tv rv) =>
ConvertFunctionToRaw (IO tv) (IO rv) where
{
importFunction rawF = do
{
rv <- rawF;
return (importValue rv);
};
};
instance (ConvertFunctionToRaw tb rb,ConvertValueToRaw ta ra) =>
ConvertFunctionToRaw (ta -> tb) (ra -> rb) where
{
importFunction rawF ta = importFunction (rawF (exportValue ta));
};
instance ConvertValueToRaw (Ptr a) (Ptr ()) where
{
importValue = castPtr;
exportValue = castPtr;
};
instance ConvertValueToRaw Word8 Word8 where
{
importValue = id;
exportValue = id;
};
etc.
--
Ashley Yakeley, Seattle WA
_______________________________________________
Glasgow-haskell-users mailing list
[EMAIL PROTECTED]
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users
