-- | Extend a monad with the ability to terminate a computation with a value
module Mini.Transformers.EitherT (
  -- * Type
  EitherT (
    EitherT
  ),

  -- * Runner
  runEitherT,

  -- * Operations
  left,
  anticipate,
) where

import Control.Applicative (
  Alternative (
    empty,
    (<|>)
  ),
 )
import Control.Monad (
  ap,
  liftM,
  (>=>),
 )
import Mini.Transformers.Class (
  MonadTrans (
    lift
  ),
 )

{-
 - Type
 -}

-- | A terminable transformer with termination /e/, inner monad /m/, return /a/
newtype EitherT e m a = EitherT
  { forall e (m :: * -> *) a. EitherT e m a -> m (Either e a)
runEitherT :: m (Either e a)
  -- ^ Unwrap an 'EitherT' computation
  }

instance (Monad m) => Functor (EitherT e m) where
  fmap :: forall a b. (a -> b) -> EitherT e m a -> EitherT e m b
fmap = (a -> b) -> EitherT e m a -> EitherT e m b
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM

instance (Monad m) => Applicative (EitherT e m) where
  pure :: forall a. a -> EitherT e m a
pure = m (Either e a) -> EitherT e m a
forall e (m :: * -> *) a. m (Either e a) -> EitherT e m a
EitherT (m (Either e a) -> EitherT e m a)
-> (a -> m (Either e a)) -> a -> EitherT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either e a -> m (Either e a)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either e a -> m (Either e a))
-> (a -> Either e a) -> a -> m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either e a
forall a b. b -> Either a b
Right
  <*> :: forall a b. EitherT e m (a -> b) -> EitherT e m a -> EitherT e m b
(<*>) = EitherT e m (a -> b) -> EitherT e m a -> EitherT e m b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap

instance (Monad m, Monoid e) => Alternative (EitherT e m) where
  empty :: forall a. EitherT e m a
empty = m (Either e a) -> EitherT e m a
forall e (m :: * -> *) a. m (Either e a) -> EitherT e m a
EitherT (m (Either e a) -> EitherT e m a)
-> (Either e a -> m (Either e a)) -> Either e a -> EitherT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either e a -> m (Either e a)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either e a -> EitherT e m a) -> Either e a -> EitherT e m a
forall a b. (a -> b) -> a -> b
$ e -> Either e a
forall a b. a -> Either a b
Left e
forall a. Monoid a => a
mempty
  EitherT e m a
m <|> :: forall a. EitherT e m a -> EitherT e m a -> EitherT e m a
<|> EitherT e m a
n =
    m (Either e a) -> EitherT e m a
forall e (m :: * -> *) a. m (Either e a) -> EitherT e m a
EitherT (m (Either e a) -> EitherT e m a)
-> m (Either e a) -> EitherT e m a
forall a b. (a -> b) -> a -> b
$
      EitherT e m a -> m (Either e a)
forall e (m :: * -> *) a. EitherT e m a -> m (Either e a)
runEitherT EitherT e m a
m
        m (Either e a) -> (Either e a -> m (Either e a)) -> m (Either e a)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (e -> m (Either e a))
-> (a -> m (Either e a)) -> Either e a -> m (Either e a)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
          (\e
e -> (e -> Either e a) -> (a -> Either e a) -> Either e a -> Either e a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (e -> Either e a
forall a b. a -> Either a b
Left (e -> Either e a) -> (e -> e) -> e -> Either e a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> e -> e
forall a. Monoid a => a -> a -> a
mappend e
e) a -> Either e a
forall a b. b -> Either a b
Right (Either e a -> Either e a) -> m (Either e a) -> m (Either e a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> EitherT e m a -> m (Either e a)
forall e (m :: * -> *) a. EitherT e m a -> m (Either e a)
runEitherT EitherT e m a
n)
          (Either e a -> m (Either e a)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either e a -> m (Either e a))
-> (a -> Either e a) -> a -> m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either e a
forall a b. b -> Either a b
Right)

instance (Monad m) => Monad (EitherT e m) where
  EitherT e m a
m >>= :: forall a b. EitherT e m a -> (a -> EitherT e m b) -> EitherT e m b
>>= a -> EitherT e m b
k =
    m (Either e b) -> EitherT e m b
forall e (m :: * -> *) a. m (Either e a) -> EitherT e m a
EitherT (m (Either e b) -> EitherT e m b)
-> m (Either e b) -> EitherT e m b
forall a b. (a -> b) -> a -> b
$
      EitherT e m a -> m (Either e a)
forall e (m :: * -> *) a. EitherT e m a -> m (Either e a)
runEitherT EitherT e m a
m
        m (Either e a) -> (Either e a -> m (Either e b)) -> m (Either e b)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (e -> m (Either e b))
-> (a -> m (Either e b)) -> Either e a -> m (Either e b)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
          (Either e b -> m (Either e b)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either e b -> m (Either e b))
-> (e -> Either e b) -> e -> m (Either e b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Either e b
forall a b. a -> Either a b
Left)
          (EitherT e m b -> m (Either e b)
forall e (m :: * -> *) a. EitherT e m a -> m (Either e a)
runEitherT (EitherT e m b -> m (Either e b))
-> (a -> EitherT e m b) -> a -> m (Either e b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> EitherT e m b
k)

instance MonadTrans (EitherT e) where
  lift :: forall (m :: * -> *) a. Monad m => m a -> EitherT e m a
lift = m (Either e a) -> EitherT e m a
forall e (m :: * -> *) a. m (Either e a) -> EitherT e m a
EitherT (m (Either e a) -> EitherT e m a)
-> (m a -> m (Either e a)) -> m a -> EitherT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Either e a) -> m a -> m (Either e a)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Either e a
forall a b. b -> Either a b
Right

{-
 - Operations
 -}

-- | Terminate the computation with a value
left :: (Monad m) => e -> EitherT e m a
left :: forall (m :: * -> *) e a. Monad m => e -> EitherT e m a
left = m (Either e a) -> EitherT e m a
forall e (m :: * -> *) a. m (Either e a) -> EitherT e m a
EitherT (m (Either e a) -> EitherT e m a)
-> (e -> m (Either e a)) -> e -> EitherT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either e a -> m (Either e a)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either e a -> m (Either e a))
-> (e -> Either e a) -> e -> m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Either e a
forall a b. a -> Either a b
Left

-- | Run a computation and get its result
anticipate :: (Monad m) => EitherT e m a -> EitherT e m (Either e a)
anticipate :: forall (m :: * -> *) e a.
Monad m =>
EitherT e m a -> EitherT e m (Either e a)
anticipate = m (Either e (Either e a)) -> EitherT e m (Either e (Either e a))
forall (m :: * -> *) a. Monad m => m a -> EitherT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Either e (Either e a)) -> EitherT e m (Either e (Either e a)))
-> (EitherT e m a -> m (Either e (Either e a)))
-> EitherT e m a
-> EitherT e m (Either e (Either e a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EitherT e m (Either e a) -> m (Either e (Either e a))
forall e (m :: * -> *) a. EitherT e m a -> m (Either e a)
runEitherT (EitherT e m (Either e a) -> m (Either e (Either e a)))
-> (EitherT e m a -> EitherT e m (Either e a))
-> EitherT e m a
-> m (Either e (Either e a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Either e a
forall a b. b -> Either a b
Right (a -> Either e a) -> EitherT e m a -> EitherT e m (Either e a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) (EitherT e m a -> EitherT e m (Either e (Either e a)))
-> (Either e (Either e a) -> EitherT e m (Either e a))
-> EitherT e m a
-> EitherT e m (Either e a)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (e -> EitherT e m (Either e a))
-> (Either e a -> EitherT e m (Either e a))
-> Either e (Either e a)
-> EitherT e m (Either e a)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Either e a -> EitherT e m (Either e a)
forall a. a -> EitherT e m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either e a -> EitherT e m (Either e a))
-> (e -> Either e a) -> e -> EitherT e m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Either e a
forall a b. a -> Either a b
Left) Either e a -> EitherT e m (Either e a)
forall a. a -> EitherT e m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure