module HaskellWorks.Error
  ( onNothing,
    onNothingM,
    onLeft,
    onLeftM,
    onLeft_,
    onLeftM_,
    onMany,
    onManyM,
    onMany_,
    onManyM_,
  ) where

import           Control.Applicative
import           Control.Monad
import           Data.Either
import           Data.Function
import           Data.List.NonEmpty
import           Data.Maybe

-- | Handle the case where a value is 'Nothing'.
onNothing :: forall a m. ()
  => Monad m
  => m a
  -> Maybe a
  -> m a
onNothing :: forall a (m :: * -> *). Monad m => m a -> Maybe a -> m a
onNothing m a
h = m a -> (a -> m a) -> Maybe a -> m a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe m a
h a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return

-- | Handle the case where an effectful function returns 'Nothing'.
onNothingM :: forall a m. ()
  => Monad m
  => m a
  -> m (Maybe a)
  -> m a
onNothingM :: forall a (m :: * -> *). Monad m => m a -> m (Maybe a) -> m a
onNothingM m a
h m (Maybe a)
f = m a -> Maybe a -> m a
forall a (m :: * -> *). Monad m => m a -> Maybe a -> m a
onNothing m a
h (Maybe a -> m a) -> m (Maybe a) -> m a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< m (Maybe a)
f

-- | Handle the case where a value is 'Left'.
onLeft :: forall e a m. ()
  => Monad m
  => (e -> m a)
  -> Either e a
  -> m a
onLeft :: forall e a (m :: * -> *).
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

-- | Handle the case where an effectful function returns 'Left'.
onLeftM :: forall e a m. ()
  => Monad m
  => (e -> m a)
  -> m (Either e a)
  -> m a
onLeftM :: forall e a (m :: * -> *).
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 e a (m :: * -> *).
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

-- | Handle the case where a value is 'Left'.
onLeft_ :: forall e a m. ()
  => Monad m
  => m a
  -> Either e a
  -> m a
onLeft_ :: forall e a (m :: * -> *). Monad m => m a -> Either e a -> m a
onLeft_ 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 (m a -> e -> m a
forall a b. a -> b -> a
const m a
f) a -> m a
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure

-- | Handle the case where an effectful function returns 'Left'.
onLeftM_ :: forall e a m. ()
  => Monad m
  => m a
  -> m (Either e a)
  -> m a
onLeftM_ :: forall e a (m :: * -> *). Monad m => m a -> m (Either e a) -> m a
onLeftM_ m a
f m (Either e a)
action = m a -> Either e a -> m a
forall e a (m :: * -> *). Monad m => m a -> Either e a -> m a
onLeft_ 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

-- | Handle the case where a list with many (more than one) elements.
onMany :: forall a m. ()
  => Monad m
  => (NonEmpty a -> m (Maybe a))
  -> [a]
  -> m (Maybe a)
onMany :: forall a (m :: * -> *).
Monad m =>
(NonEmpty a -> m (Maybe a)) -> [a] -> m (Maybe a)
onMany NonEmpty a -> m (Maybe a)
h [a]
as = case [a]
as of
    []       -> Maybe a -> m (Maybe a)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe a
forall a. Maybe a
Nothing
    [a
x]      -> Maybe a -> m (Maybe a)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> Maybe a
forall a. a -> Maybe a
Just a
x)
    (a
x : [a]
xs) -> NonEmpty a -> m (Maybe a)
h (a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [a]
xs)

-- | Handle the case where an effectul function returns a list with many (more than one) elements.
onManyM :: forall a m. ()
  => Monad m
  => (NonEmpty a -> m (Maybe a))
  -> m [a]
  -> m (Maybe a)
onManyM :: forall a (m :: * -> *).
Monad m =>
(NonEmpty a -> m (Maybe a)) -> m [a] -> m (Maybe a)
onManyM NonEmpty a -> m (Maybe a)
h m [a]
f =
  m [a]
f m [a] -> ([a] -> m (Maybe a)) -> m (Maybe a)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (NonEmpty a -> m (Maybe a)) -> [a] -> m (Maybe a)
forall a (m :: * -> *).
Monad m =>
(NonEmpty a -> m (Maybe a)) -> [a] -> m (Maybe a)
onMany NonEmpty a -> m (Maybe a)
h

-- | Handle the case where a list with many (more than one) elements.
onMany_ :: forall a m. ()
  => Monad m
  => m (Maybe a)
  -> [a]
  -> m (Maybe a)
onMany_ :: forall a (m :: * -> *).
Monad m =>
m (Maybe a) -> [a] -> m (Maybe a)
onMany_ m (Maybe a)
h [a]
as = case [a]
as of
    []  -> Maybe a -> m (Maybe a)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe a
forall a. Maybe a
Nothing
    [a
x] -> Maybe a -> m (Maybe a)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> Maybe a
forall a. a -> Maybe a
Just a
x)
    [a]
_   -> m (Maybe a)
h

-- | Handle the case where an effectul function returns a list with many (more than one) elements.
onManyM_ :: forall a m. ()
  => Monad m
  => m (Maybe a)
  -> m [a]
  -> m (Maybe a)
onManyM_ :: forall a (m :: * -> *).
Monad m =>
m (Maybe a) -> m [a] -> m (Maybe a)
onManyM_ m (Maybe a)
h m [a]
f =
  m [a]
f m [a] -> ([a] -> m (Maybe a)) -> m (Maybe a)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= m (Maybe a) -> [a] -> m (Maybe a)
forall a (m :: * -> *).
Monad m =>
m (Maybe a) -> [a] -> m (Maybe a)
onMany_ m (Maybe a)
h