module HaskellWorks.Polysemy.Error
  ( onLeft
  , onNothing
  , onLeftM
  , onNothingM
  , trap
  ) where

import           HaskellWorks.Polysemy.Prelude
import           Polysemy
import           Polysemy.Error

onLeft :: Monad m => (e -> m a) -> Either e a -> m a
onLeft :: forall (m :: * -> *) e a.
Monad m =>
(e -> m a) -> Either e a -> m a
onLeft e -> m a
f = (e -> m a) -> (a -> m a) -> Either e a -> m a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either e -> m a
f a -> m a
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure

onNothing :: Monad m => m b -> Maybe b -> m b
onNothing :: forall (m :: * -> *) b. Monad m => m b -> Maybe b -> m b
onNothing m b
h = m b -> (b -> m b) -> Maybe b -> m b
forall b a. b -> (a -> b) -> Maybe a -> b
maybe m b
h b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return

onLeftM :: Monad m => (e -> m a) -> m (Either e a) -> m a
onLeftM :: forall (m :: * -> *) e a.
Monad m =>
(e -> m a) -> m (Either e a) -> m a
onLeftM e -> m a
f m (Either e a)
action = (e -> m a) -> Either e a -> m a
forall (m :: * -> *) e a.
Monad m =>
(e -> m a) -> Either e a -> m a
onLeft e -> m a
f (Either e a -> m a) -> m (Either e a) -> m a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< m (Either e a)
action

onNothingM :: Monad m => m b -> m (Maybe b) -> m b
onNothingM :: forall (m :: * -> *) b. Monad m => m b -> m (Maybe b) -> m b
onNothingM m b
h m (Maybe b)
f = m b -> Maybe b -> m b
forall (m :: * -> *) b. Monad m => m b -> Maybe b -> m b
onNothing m b
h (Maybe b -> m b) -> m (Maybe b) -> m b
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< m (Maybe b)
f

trap :: forall e r a. ()
  => (e -> Sem r a)
  -> Sem (Error e ': r) a
  -> Sem r a
trap :: forall e (r :: EffectRow) a.
(e -> Sem r a) -> Sem (Error e : r) a -> Sem r a
trap e -> Sem r a
h Sem (Error e : r) a
f =
  Sem (Error e : r) a -> Sem r (Either e a)
forall e (r :: EffectRow) a.
Sem (Error e : r) a -> Sem r (Either e a)
runError Sem (Error e : r) a
f Sem r (Either e a) -> (Either e a -> Sem r a) -> Sem r a
forall a b. Sem r a -> (a -> Sem r b) -> Sem r b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (e -> Sem r a) -> (a -> Sem r a) -> Either e a -> Sem r a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either e -> Sem r a
h a -> Sem r a
forall a. a -> Sem r a
forall (f :: * -> *) a. Applicative f => a -> f a
pure