{-# LANGUAGE CPP #-}
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE NoImplicitPrelude #-}

module Protolude.Exceptions (
  hush,
  note,
  tryIO,
) where

import Protolude.Base (IO)
import Data.Function ((.))
import Control.Monad.Trans (liftIO)
import Control.Monad.IO.Class (MonadIO)
import Control.Monad.Except (ExceptT(ExceptT), MonadError, throwError)
import Control.Exception as Exception
import Control.Applicative
import Data.Maybe (Maybe, maybe)
import Data.Either (Either(Left,Right))

hush :: Alternative m => Either e a -> m a
hush :: forall (m :: * -> *) e a. Alternative m => Either e a -> m a
hush (Left e
_)  = forall (f :: * -> *) a. Alternative f => f a
empty
hush (Right a
x) = forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x

-- To suppress redundant applicative constraint warning on GHC 8.0
#if ( __GLASGOW_HASKELL__ >= 800 )
note :: (MonadError e m) => e -> Maybe a -> m a
note :: forall e (m :: * -> *) a. MonadError e m => e -> Maybe a -> m a
note e
err = forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError e
err) forall (f :: * -> *) a. Applicative f => a -> f a
pure
#else
note :: (MonadError e m, Applicative m) => e -> Maybe a -> m a
note err = maybe (throwError err) pure
#endif

tryIO :: MonadIO m => IO a -> ExceptT IOException m a
tryIO :: forall (m :: * -> *) a.
MonadIO m =>
IO a -> ExceptT IOException m a
tryIO = forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e a. Exception e => IO a -> IO (Either e a)
Exception.try