implementation of file-related modules

[Simon Marlow]

> I've been looking over some of the file-related modules such as
> System.Directory and System.Posix.{Directory,Files}, and I have some
> questions.

My 2p:

> * Some languages have a means of building paths in a portable way.  It
>   would be nice if we had access a file separator (like "/" in unix
>   and "\" in windows).

I've been against doing this in the past, because filename conventions
differ so much between platforms (case sensitivity, length restrictions
on components, syntax for drivenames, what is the meaning of consecutive
pathname separators, etc.).

However, there's clearly a need for some way to do simple pathname
manipulations in a portable way.  So my suggestion is to have something
like:

    parentDirectory :: FilePath -> Mabye FilePath
    relativeToDirectory :: FilePath -> FilePath -> Maybe FilePath
    normaliseFilePath :: FilePath -> FilePath

so you could say things like

    "my.conf" `relativeToDirectory` configDir

It occurs to me that FilePath should be an abstract type.  That would
force the issue: we'd have to deal with all those existing cases which
manipulate FilePaths and work out what abstractions we need.

I don't like the idea of having a System.Directory.Native whose
interface changes depending on the host platform.  I think it's because
platform-dependent APIs tend to lead to fine-grained #ifdefing in client
code, and hence subtle portability problems.  In libraries I try to
stick to modules whose presence (only) depends on the platform, but
there are definitely existing cases which violate this principle.

>     "path.separator" Path separator (for example, ":")

looks like a bad idea to me: application dependent.

>     "file.separator" File separator (for example, "/")
>     "user.home"      User home directory
>     "user.name"	     User account name
> 
>     // might come in useful:
>     "os.arch"    Operating system architecture
>     "os.name"    Operating system name
>     "os.version" Operating system version

System.Info already provides these (except the version).

> * Another item that would be useful in the System.Directory class
>   would be some kind of config file path.  On Debian, that would be
>   "/etc", on some systems, it might tend to be more often
>   "/usr/local/etc".  (I'm not sure if there's a good way to abstract
>   the difference between a user config file and a system config file.
>   User config files tend to be in ~/ and start with a dot whereas
>   system config files end up in /etc, and don't start with a dot.)

The location of config files is something you want to specify via the
build system.  eg. ./configure --prefix=/opt should cause configuration
files to be placed under /opt instead of the default location
(/usr/local?).  Which means that if the config file location were
provided via a Haskell library, that library would have to consult an
environment variable or something.  ( looking through the followups, it
looks like Ketil already mentioned this point).

This just doesn't look like the right abstraction to me.  I think it's
better to let the build system (or library infrastructure) provide this
kind of information, perhaps by auto-generating a module.

Cheers,
	Simon