[Haskell-cafe] Re: [Haskell] installing streams library
Jacques Carette
carette at mcmaster.ca
Wed May 31 09:33:39 EDT 2006
[See comments at bottom]
Bulat Ziganshin wrote:
> Finally i've implemented the following (you then would use
> 'withForeignPtr' to work with contents of ForeignPtr):
>
> -- -----------------------------------------------------------------------------
> -- Encode/decode contents of memory buffer
>
> encodePtr :: (Binary a, Integral size) => a -> IO (ForeignPtr x, size)
> encodePtrLE :: (Binary a, Integral size) => a -> IO (ForeignPtr x, size)
> encodePtrBitAligned :: (Binary a, Integral size) => a -> IO (ForeignPtr x, size)
> encodePtrBitAlignedLE :: (Binary a, Integral size) => a -> IO (ForeignPtr x, size)
> encodePtr = encodePtr' openByteAligned
> encodePtrLE = encodePtr' openByteAlignedLE
> encodePtrBitAligned = encodePtr' openBitAligned
> encodePtrBitAlignedLE = encodePtr' openBitAlignedLE
>
> decodePtr :: (Binary a, Integral size) => Ptr x -> size -> IO a
> decodePtrLE :: (Binary a, Integral size) => Ptr x -> size -> IO a
> decodePtrBitAligned :: (Binary a, Integral size) => Ptr x -> size -> IO a
> decodePtrBitAlignedLE :: (Binary a, Integral size) => Ptr x -> size -> IO a
>
> decodePtr = decodePtr' openByteAligned
> decodePtrLE = decodePtr' openByteAlignedLE
> decodePtrBitAligned = decodePtr' openBitAligned
> decodePtrBitAlignedLE = decodePtr' openBitAlignedLE
>
Am I the only one who finds this encoding-of-types in the _name_ of a
function quite distateful? There is no type safety being enforced here,
no ensuring one will not be encoding a Ptr one way and decoding it
another. Why not use Haskell's type system to help you there?
One could imagine putting encodePtr' and decodePtr' in a type class for
example? Or many other solutions.
This is not meant to be a general critique of this habit of encoding
types into function names, not of the particular instance above. My
interest in starting this thread is to discuss the solutions that work,
and the situations where no solution currently seems to exist.
I believe there may be instances of encoding-types-in-names that are
currently necessary in Haskell because the type system is not powerful
enough to do anything else. Using Typeable and a type-witness just
moves the problem, it does not ``solve'' it.
Jacques
More information about the Haskell-Cafe
mailing list