{-# LANGUAGE CPP #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE OverlappingInstances #-}


{-| Defines the (not so useful anymore) 'MonadCatch' type class.
-}

module Control.Monad.Exception.Catch (
       module Control.Monad,
       module Control.Monad.Exception.Throws,
       MonadCatch(..),
       Exception(..), SomeException(..),
       ) where

import Control.Monad

#if __GLASGOW_HASKELL__ < 610
import Control.Exception.Extensible (Exception(..), SomeException)
import qualified Control.Exception.Extensible as Control.Exception
#else
import Control.Exception (Exception(..), SomeException)
import qualified Control.Exception
#endif

import Control.Monad.Exception.Throws

class (Monad m, Monad m') => MonadCatch e m m' | e m -> m', e m' -> m where
   catch   :: m a -> (e -> m' a) -> m' a
   catchWithSrcLoc :: m a -> ([String] -> e -> m' a) -> m' a
   catchWithSrcLoc m a
m [String] -> e -> m' a
h = m a -> (e -> m' a) -> m' a
forall e (m :: * -> *) (m' :: * -> *) a.
MonadCatch e m m' =>
m a -> (e -> m' a) -> m' a
Control.Monad.Exception.Catch.catch m a
m ([String] -> e -> m' a
h [])

instance Exception e => MonadCatch e IO IO where
   catch :: IO a -> (e -> IO a) -> IO a
catch   = IO a -> (e -> IO a) -> IO a
forall e a. Exception e => IO a -> (e -> IO a) -> IO a
Control.Exception.catch