[Haskell-cafe] Re: ANNOUNCE: New versions of ALL the monadic regions packages

Bas van Dijk v.dijk.bas at gmail.com
Thu Jan 7 10:25:34 EST 2010


As can be seen from the documentation of 'safer-file-handles', I'm
currently not satisfied at all about my implementation of the standard
files (stdin, stdout and stderr). To quote the docs:

BIG WARNING: I'm not satisfied with my current implementation of the
standard handles (stdin, stdout and stderr)! Currently the standard
handles are regional computations that return the regional file
handles to the respected standard handles. There are 4 problems with
this approach:

* When the region terminates in which you call one of the standard
handles the respected handle will be closed. I think this is not the
expected behaviour. I would expect the standard handles to always
remain open.

* In System.IO the standard handles are pure values. My standard
handles are monadic computations which makes them harder to work with.

* There is no way to explicitly close a standard handle. Indeed, the
whole purpose of lightweight monadic regions is to automatically close
handles. However, when writing a Unix daemon for example, you need to
be able to explicitly close the standard handles.

* When reading 'man stdin' I'm confused if the standard handles are
always open on program startup:

quote 'man stdin':

"...Under normal circumstances every Unix program has three streams
opened for it when it starts up, one for input, one for output, and
one for printing diagnostic or error messages..."

"...The stdin, stdout, and stderr macros conform to C89 and this
standard also stipulates that these three streams shall be open at
program startup...."

So now I'm confused... are these standard file handles always open on
program startup or are there abnormal situations when they are closed?

Maybe I just have to believe the documentation in System.IO which
specifies that they are always initially open.

If the standard handles are closed on startup using a handle returned
from one of the standard handles will result in an exception! This
would be a violation of my safety guarantees which is unacceptable.

Does anyone have a solution or an rough idea how to solve it?



More information about the Haskell-Cafe mailing list