interface System.IO.Error where {

{-# NEED #-}
instance Prelude.Functor NHC.Internal.IO;

{-# NEED #-}
instance Prelude.Monad NHC.Internal.IO;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Fractional (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.RealFrac (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Num (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Real (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Enum (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Read a,Prelude.Integral a) => Prelude.Read (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Ord (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Eq (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Eq IO.Handle;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Show (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Show IO.Handle;

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (NHC.Internal.IO a);
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface ! System.IO.Error
{-# NEED isUserErrorType #-}
isUserErrorType{-# 1 #-}::(IOErrorType -> Prelude.Bool);

{-# NEED isPermissionErrorType #-}
isPermissionErrorType{-# 1 #-}::(IOErrorType -> Prelude.Bool);

{-# NEED isIllegalOperationErrorType #-}
isIllegalOperationErrorType{-# 1 #-}::(IOErrorType -> Prelude.Bool);

{-# NEED isEOFErrorType #-}
isEOFErrorType{-# 1 #-}::(IOErrorType -> Prelude.Bool);

{-# NEED isFullErrorType #-}
isFullErrorType{-# 1 #-}::(IOErrorType -> Prelude.Bool);

{-# NEED isAlreadyInUseErrorType #-}
isAlreadyInUseErrorType{-# 1 #-}::(IOErrorType -> Prelude.Bool);

{-# NEED isDoesNotExistErrorType #-}
isDoesNotExistErrorType{-# 1 #-}::(IOErrorType -> Prelude.Bool);

{-# NEED isAlreadyExistsErrorType #-}
isAlreadyExistsErrorType{-# 1 #-}::(IOErrorType -> Prelude.Bool);

{-# NEED userErrorType #-}
userErrorType{-# 0 #-}::IOErrorType;

{-# NEED permissionErrorType #-}
permissionErrorType{-# 0 #-}::IOErrorType;

{-# NEED illegalOperationErrorType #-}
illegalOperationErrorType{-# 0 #-}::IOErrorType;

{-# NEED eofErrorType #-}
eofErrorType{-# 0 #-}::IOErrorType;

{-# NEED fullErrorType #-}
fullErrorType{-# 0 #-}::IOErrorType;

{-# NEED alreadyInUseErrorType #-}
alreadyInUseErrorType{-# 0 #-}::IOErrorType;

{-# NEED doesNotExistErrorType #-}
doesNotExistErrorType{-# 0 #-}::IOErrorType;

{-# NEED alreadyExistsErrorType #-}
alreadyExistsErrorType{-# 0 #-}::IOErrorType;

{-# NEED IOErrorType #-}
data IOErrorType;
interface ! Prelude
{-# NEED catch #-}
catch{-# 2 #-}::((NHC.Internal.IO a) -> ((Prelude.IOError -> (NHC.Internal.IO a)) -> (NHC.Internal.IO a)));
interface ! IO
{-# NEED ioeGetHandle #-}
ioeGetHandle{-# 1 #-}::(Prelude.IOError -> (Prelude.Maybe IO.Handle));
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
interface ! IO
{-# NEED ioeGetFileName #-}
ioeGetFileName{-# 1 #-}::(Prelude.IOError -> (Prelude.Maybe Prelude.FilePath));

{-# NEED ioeGetErrorString #-}
ioeGetErrorString{-# 1 #-}::(Prelude.IOError -> Prelude.String);

{-# NEED isEOFError #-}
isEOFError{-# 1 #-}::(Prelude.IOError -> Prelude.Bool);

{-# NEED isUserError #-}
isUserError{-# 1 #-}::(Prelude.IOError -> Prelude.Bool);

{-# NEED isPermissionError #-}
isPermissionError{-# 1 #-}::(Prelude.IOError -> Prelude.Bool);

{-# NEED isIllegalOperation #-}
isIllegalOperation{-# 1 #-}::(Prelude.IOError -> Prelude.Bool);

{-# NEED isFullError #-}
isFullError{-# 1 #-}::(Prelude.IOError -> Prelude.Bool);

{-# NEED isAlreadyInUseError #-}
isAlreadyInUseError{-# 1 #-}::(Prelude.IOError -> Prelude.Bool);

{-# NEED isDoesNotExistError #-}
isDoesNotExistError{-# 1 #-}::(Prelude.IOError -> Prelude.Bool);

{-# NEED isAlreadyExistsError #-}
isAlreadyExistsError{-# 1 #-}::(Prelude.IOError -> Prelude.Bool);

{-# NEED try #-}
try{-# 1 #-}::((NHC.Internal.IO a) -> (NHC.Internal.IO (Prelude.Either Prelude.IOError a)));
interface ! Prelude
{-# NEED userError #-}
userError{-# 1 #-}::(Prelude.String -> Prelude.IOError);

{-# NEED ioError #-}
ioError{-# 1 #-}::(Prelude.IOError -> (NHC.Internal.IO a));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface ! Prelude
{-# NEED IOError #-}
data IOError;
}