[Haskell-cafe] haskell and fuse

David Roundy droundy at darcs.net
Sun Aug 28 09:03:59 EDT 2005

Hi all,

I worked for a bit while I was on vacation on a haskell interface to
libfuse, which I thought some of you might find interesting.  It is VERY
much a halted-work-in-progress, as I didn't get very far, and don't have
time to continue work on it.  You can get what there is with

darcs get http://abridgegame.org/repos/fuse_example

or browse at


It's basically an attempt at combining a nice DarcsIO-style filesystem
interface on the haskell side (called FuseIO) with an interface to libfuse
(which is a library for creating filesystems from user space on linux).

The main file is (quite confusingly) called hello.hs, and you can see that
it basically just imports one function from FuseIO and one from Fuse.  It
tries to do the equivalent of `mount --bind dir1 dir2`, execpt that there's
no support for writing to files, or in general modifying the mounted

I had been thinking (although I now have no time for this) about the
possibility of implementing a caching distributed network filesystem which
had git as its backend.  Of course, I'd start with just a local filesystem
with git as the backend, which would be a bit stupid, although it'd have
the (very minor) advantage that identical files would be effectively
hard-linked as far as space use goes.

The FuseIO module itself might be rather interesting for other projects
(e.g. darcs), or even (one could imagine) as an alternative to the haskell
standard IO libraries for filesystem access, since it'd allow you to write
a function that is guaranteed by the typesystem to do nothing but read from
a filesystem, and it'd also allow writing polymorphic filesystem
access/modification code that could be applied outside the IO monad
(e.g. to Slurpies).  It would also allow one to use treat network objects
(e.g. http or ftp) as filesystems.

The Fuse side of things uses hsffig to generate an interface to libfuse,
and then translates the libfuse interface into FuseIO commands, so
implementing a new sort of filesystem (e.g. sshfs) would require modifying
neither FuseIO nor Fuse, but instead just implementing a new FS and
plugging it in.  But the Fuse interface is very limited, as is the FuseIO
interface (which doesn't support, for example, file permissions), so to
make a real useful filesystem would require considerable extension of both
David Roundy

More information about the Haskell-Cafe mailing list