binary files in haskell

John Meacham
Thu, 8 Feb 2001 01:53:15 -0800

Since there seems to be general support for the idea of some sort of
Portable Byte IO package, I will work on am implementation of my
proposal for ghc being the platform I am most familiar with. I really
like the simplicity of the hPut and hGet idea and will probably use it
as my mechanism for implementation on ghc, however for a Portable API
which should be implementable across a wide variety of Haskell 98
implementations and machine architectures it is too low level to allow
certain portable applications to be written. I made the API at pretty
much the exact level of the Haskell 98 IO API since it seems to strike a
good balance between portability and expressiveness/power. 

A nice advantage of using my mid-level routines is that there are very
little requirements placed on 'Byte' as a type, this means that as long
as to the outside world you only read in 8 bit values and spit 8 bit
values out you can represent it internally however you want. 

for example you might have a machine where a 16 bit word is the smallest
addressable entity, if you relied on hPut Word8 then your program would
not work since Word8 cannot exist on that platform. however if you made
Byte be 16 bits and only used the bottom half of each word then your
program will run unchanged even among architectures such as this.

my requirements for Byte were going to basically mirror the C
requirements for char, The smallest individually addressable integral
type greater than 8 bits in width. The trick that makes programs using
Byte portable is that and ByteIO.write only utilize the
lower 8 bits of that datatype at a time, therefore one can write
portable Haskell applications which work on network sockets and file
streams in a machine independent fashion.

Anyone who is concerned about the space requirements of using up a
little more memory than necessary on certain architectures will have to
know about how those architectures store stuff in memory anyway to pack
values into the architecture primitives properly so they can use hPut
and hGet with explicit word widths...

I guess what would be nice would be a portable ByteIO as the standard
mid-level interface and the hPut, hGet idea available on those platforms
which support Storable since they seem to make sense as the primitives
for Haskell implementations which allow such fine grained access to the
hardware representations.  (but such access should not be required from
a haskell implementation in order to write portable programs which can
communicate in externally defined formats)


John Meacham
California Institute of Technology, Alum.