These ungainly-named functions are defined in ``System.IO.Error`` for
interrogating error values in a ``catch`` handler function. They all
have type ``IOError -> Bool``, and return ``True`` iff the error value
represents an error of the appropriate type.

    ``isAlreadyExistsError :: IOError -> Bool``
        The operation failed because one of its arguments does not
        exist. For example, if you ``createDirectory "/tmp/"``, you
        will get an "already exists" error (at least on any sane Unix
        box!).

    ``isDoesNotExistError :: IOError -> Bool``
        The operation failed because one of its arguments does not
        exist. For example, if you ``createDirectory "/tmp/foo/bar"``,
        you will get a "does not exist" error (unless you happen to have
        a directory called ``/tmp/foo``!).

    ``isAlreadyInUseError :: IOError -> Bool``
        The operation failed because one of its arguments is a
        single-use resource, which is already being used. This is a
        slightly hard one to provoke, but ``do { writeFile "/tmp/foo"
        "foo"; x <- readFile "/tmp/foo"; writeFile "/tmp/foo" "qux" }``
        does the job. The reason for this is that ``readFile`` reads the
        file lazily, so since we haven't used its result (the value of
        ``x``), the file is still in a "semi-closed" state. Thus the
        second ``writeFile`` fails with this error.

    ``isFullError``
        The operation failed because the device is full.

    ``isEOFError``
        The operation failed because the end of file has been reached.

    ``isIllegalOperation``
        A catch-all error: the operation was not possible.

    ``isPermissionError``
        The operation failed because the user does not have sufficient
        operating system privilege to perform that operation.

    ``isUserError``
        A programmer-defined error value has been raised using ``fail``.