{-# LANGUAGE Safe #-}
module Universum.Monad.Either
( fromLeft
, fromRight
, maybeToLeft
, maybeToRight
, leftToMaybe
, rightToMaybe
, whenLeft
, whenLeftM
, whenRight
, whenRightM
) where
import Control.Applicative (Applicative)
import Control.Monad (Monad (..))
import Data.Function (const)
import Data.Maybe (Maybe (..), maybe)
import Universum.Applicative (pass)
import Universum.Monad.Reexport (Either (..), either)
fromLeft :: a -> Either a b -> a
fromLeft _ (Left a) = a
fromLeft a (Right _) = a
fromRight :: b -> Either a b -> b
fromRight b (Left _) = b
fromRight _ (Right b) = b
leftToMaybe :: Either l r -> Maybe l
leftToMaybe = either Just (const Nothing)
rightToMaybe :: Either l r -> Maybe r
rightToMaybe = either (const Nothing) Just
maybeToRight :: l -> Maybe r -> Either l r
maybeToRight l = maybe (Left l) Right
maybeToLeft :: r -> Maybe l -> Either l r
maybeToLeft r = maybe (Right r) Left
whenLeft :: Applicative f => Either l r -> (l -> f ()) -> f ()
whenLeft (Left l) f = f l
whenLeft (Right _) _ = pass
{-# INLINE whenLeft #-}
whenLeftM :: Monad m => m (Either l r) -> (l -> m ()) -> m ()
whenLeftM me f = me >>= \e -> whenLeft e f
{-# INLINE whenLeftM #-}
whenRight :: Applicative f => Either l r -> (r -> f ()) -> f ()
whenRight (Left _) _ = pass
whenRight (Right r) f = f r
{-# INLINE whenRight #-}
whenRightM :: Monad m => m (Either l r) -> (r -> m ()) -> m ()
whenRightM me f = me >>= \e -> whenRight e f
{-# INLINE whenRightM #-}