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

import           HaskellWorks.Polysemy.Prelude

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