{-# LANGUAGE CPP                        #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE DeriveTraversable          #-}
{-# LANGUAGE DerivingStrategies         #-}
{-# LANGUAGE ExplicitNamespaces         #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE PatternSynonyms            #-}

#if __GLASGOW_HASKELL__ >= 906
-- To suppress:
--
-- src\Control\Monad\Trans\Except\Result.hs:81:21: warning: [GHC-30606] [-Wredundant-constraints]
--     • Redundant constraint: Eq a
--     • When deriving the instance for (Eq1 (ResultT m))
--
-- A newer 'transformers' package may fix this warning.
{-# OPTIONS_GHC -Wno-redundant-constraints #-}
#endif
{-# OPTIONS_HADDOCK show-extensions #-}

-- | This monad transformer extends a monad with the ability to fail.
module Control.Monad.Trans.Except.Result
  ( -- * The Result monad
    type Result
  , pattern Result
  , runResult
    -- * The ResultT monad transformer
  , type ResultT (ResultT)
  , runResultT
  , mapResultT
    -- * Exception operations
  , throwE
  , catchE
    -- * Lifting other operations
  , liftCallCC
  , liftListen
  , liftPass
  ) where

import           Control.Monad.Signatures   (CallCC, Listen, Pass)
import           Control.Monad.Trans.Class  (MonadTrans)
import           Control.Monad.Trans.Except (Except, ExceptT (ExceptT), mapExceptT, runExceptT)
import qualified Control.Monad.Trans.Except as Except

import Control.Applicative        (Alternative)
import Control.Monad              (MonadPlus)
import Control.Monad.Cont.Class   (MonadCont)
import Control.Monad.Fix          (MonadFix)
import Control.Monad.IO.Class     (MonadIO)
import Control.Monad.Reader.Class (MonadReader)
import Control.Monad.RWS.Class    (MonadRWS)
import Control.Monad.State.Class  (MonadState)
import Control.Monad.Writer.Class (MonadWriter)
import Control.Monad.Zip          (MonadZip)
import Data.Functor.Classes       (Eq1, Ord1, Read1 (liftReadPrec), Show1 (liftShowsPrec), readData, readUnaryWith,
                                   showsUnaryWith)
import Data.Functor.Contravariant (Contravariant)
import Data.Functor.Identity      (Identity)
import GHC.Generics               (Generic)

#if !MIN_VERSION_base(4,13,0)
import Control.Monad.Fail (MonadFail (fail))
#endif

-- | A result monad.
type Result = ResultT Identity

-- | Wrap @'Except' 'String' a@.
pattern Result :: Except String a -> Result a
pattern $mResult :: forall {r} {a}.
Result a -> (Except String a -> r) -> ((# #) -> r) -> r
$bResult :: forall a. Except String a -> Result a
Result e = ResultT e

-- | Unwrap @'Result' a@.
runResult :: Result a -> Except String a
runResult :: forall a. Result a -> Except String a
runResult = ResultT Identity a -> ExceptT String Identity a
forall (m :: * -> *) a. ResultT m a -> ExceptT String m a
runResultT
{-# INLINE runResult #-}

-- | A monad transformer that is similar to 'ExceptT' except a 'MonadFail' instance.
--
-- @
-- 'fail' = 'ResultT' . 'throwE'
-- @
newtype ResultT m a =
  ResultT
    { -- | Unwrap @'ResultT' m a@.
      forall (m :: * -> *) a. ResultT m a -> ExceptT String m a
runResultT :: ExceptT String m a
    }
  deriving stock (Int -> ResultT m a -> ShowS
[ResultT m a] -> ShowS
ResultT m a -> String
(Int -> ResultT m a -> ShowS)
-> (ResultT m a -> String)
-> ([ResultT m a] -> ShowS)
-> Show (ResultT m a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (m :: * -> *) a.
(Show1 m, Show a) =>
Int -> ResultT m a -> ShowS
forall (m :: * -> *) a. (Show1 m, Show a) => [ResultT m a] -> ShowS
forall (m :: * -> *) a. (Show1 m, Show a) => ResultT m a -> String
$cshowsPrec :: forall (m :: * -> *) a.
(Show1 m, Show a) =>
Int -> ResultT m a -> ShowS
showsPrec :: Int -> ResultT m a -> ShowS
$cshow :: forall (m :: * -> *) a. (Show1 m, Show a) => ResultT m a -> String
show :: ResultT m a -> String
$cshowList :: forall (m :: * -> *) a. (Show1 m, Show a) => [ResultT m a] -> ShowS
showList :: [ResultT m a] -> ShowS
Show, ReadPrec [ResultT m a]
ReadPrec (ResultT m a)
Int -> ReadS (ResultT m a)
ReadS [ResultT m a]
(Int -> ReadS (ResultT m a))
-> ReadS [ResultT m a]
-> ReadPrec (ResultT m a)
-> ReadPrec [ResultT m a]
-> Read (ResultT m a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall (m :: * -> *) a. (Read1 m, Read a) => ReadPrec [ResultT m a]
forall (m :: * -> *) a. (Read1 m, Read a) => ReadPrec (ResultT m a)
forall (m :: * -> *) a.
(Read1 m, Read a) =>
Int -> ReadS (ResultT m a)
forall (m :: * -> *) a. (Read1 m, Read a) => ReadS [ResultT m a]
$creadsPrec :: forall (m :: * -> *) a.
(Read1 m, Read a) =>
Int -> ReadS (ResultT m a)
readsPrec :: Int -> ReadS (ResultT m a)
$creadList :: forall (m :: * -> *) a. (Read1 m, Read a) => ReadS [ResultT m a]
readList :: ReadS [ResultT m a]
$creadPrec :: forall (m :: * -> *) a. (Read1 m, Read a) => ReadPrec (ResultT m a)
readPrec :: ReadPrec (ResultT m a)
$creadListPrec :: forall (m :: * -> *) a. (Read1 m, Read a) => ReadPrec [ResultT m a]
readListPrec :: ReadPrec [ResultT m a]
Read, ResultT m a -> ResultT m a -> Bool
(ResultT m a -> ResultT m a -> Bool)
-> (ResultT m a -> ResultT m a -> Bool) -> Eq (ResultT m a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (m :: * -> *) a.
(Eq1 m, Eq a) =>
ResultT m a -> ResultT m a -> Bool
$c== :: forall (m :: * -> *) a.
(Eq1 m, Eq a) =>
ResultT m a -> ResultT m a -> Bool
== :: ResultT m a -> ResultT m a -> Bool
$c/= :: forall (m :: * -> *) a.
(Eq1 m, Eq a) =>
ResultT m a -> ResultT m a -> Bool
/= :: ResultT m a -> ResultT m a -> Bool
Eq, Eq (ResultT m a)
Eq (ResultT m a) =>
(ResultT m a -> ResultT m a -> Ordering)
-> (ResultT m a -> ResultT m a -> Bool)
-> (ResultT m a -> ResultT m a -> Bool)
-> (ResultT m a -> ResultT m a -> Bool)
-> (ResultT m a -> ResultT m a -> Bool)
-> (ResultT m a -> ResultT m a -> ResultT m a)
-> (ResultT m a -> ResultT m a -> ResultT m a)
-> Ord (ResultT m a)
ResultT m a -> ResultT m a -> Bool
ResultT m a -> ResultT m a -> Ordering
ResultT m a -> ResultT m a -> ResultT m a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (m :: * -> *) a. (Ord1 m, Ord a) => Eq (ResultT m a)
forall (m :: * -> *) a.
(Ord1 m, Ord a) =>
ResultT m a -> ResultT m a -> Bool
forall (m :: * -> *) a.
(Ord1 m, Ord a) =>
ResultT m a -> ResultT m a -> Ordering
forall (m :: * -> *) a.
(Ord1 m, Ord a) =>
ResultT m a -> ResultT m a -> ResultT m a
$ccompare :: forall (m :: * -> *) a.
(Ord1 m, Ord a) =>
ResultT m a -> ResultT m a -> Ordering
compare :: ResultT m a -> ResultT m a -> Ordering
$c< :: forall (m :: * -> *) a.
(Ord1 m, Ord a) =>
ResultT m a -> ResultT m a -> Bool
< :: ResultT m a -> ResultT m a -> Bool
$c<= :: forall (m :: * -> *) a.
(Ord1 m, Ord a) =>
ResultT m a -> ResultT m a -> Bool
<= :: ResultT m a -> ResultT m a -> Bool
$c> :: forall (m :: * -> *) a.
(Ord1 m, Ord a) =>
ResultT m a -> ResultT m a -> Bool
> :: ResultT m a -> ResultT m a -> Bool
$c>= :: forall (m :: * -> *) a.
(Ord1 m, Ord a) =>
ResultT m a -> ResultT m a -> Bool
>= :: ResultT m a -> ResultT m a -> Bool
$cmax :: forall (m :: * -> *) a.
(Ord1 m, Ord a) =>
ResultT m a -> ResultT m a -> ResultT m a
max :: ResultT m a -> ResultT m a -> ResultT m a
$cmin :: forall (m :: * -> *) a.
(Ord1 m, Ord a) =>
ResultT m a -> ResultT m a -> ResultT m a
min :: ResultT m a -> ResultT m a -> ResultT m a
Ord, (forall x. ResultT m a -> Rep (ResultT m a) x)
-> (forall x. Rep (ResultT m a) x -> ResultT m a)
-> Generic (ResultT m a)
forall x. Rep (ResultT m a) x -> ResultT m a
forall x. ResultT m a -> Rep (ResultT m a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (m :: * -> *) a x. Rep (ResultT m a) x -> ResultT m a
forall (m :: * -> *) a x. ResultT m a -> Rep (ResultT m a) x
$cfrom :: forall (m :: * -> *) a x. ResultT m a -> Rep (ResultT m a) x
from :: forall x. ResultT m a -> Rep (ResultT m a) x
$cto :: forall (m :: * -> *) a x. Rep (ResultT m a) x -> ResultT m a
to :: forall x. Rep (ResultT m a) x -> ResultT m a
Generic, (forall a b. (a -> b) -> ResultT m a -> ResultT m b)
-> (forall a b. a -> ResultT m b -> ResultT m a)
-> Functor (ResultT m)
forall a b. a -> ResultT m b -> ResultT m a
forall a b. (a -> b) -> ResultT m a -> ResultT m b
forall (m :: * -> *) a b.
Functor m =>
a -> ResultT m b -> ResultT m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> ResultT m a -> ResultT m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> ResultT m a -> ResultT m b
fmap :: forall a b. (a -> b) -> ResultT m a -> ResultT m b
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> ResultT m b -> ResultT m a
<$ :: forall a b. a -> ResultT m b -> ResultT m a
Functor, (forall m. Monoid m => ResultT m m -> m)
-> (forall m a. Monoid m => (a -> m) -> ResultT m a -> m)
-> (forall m a. Monoid m => (a -> m) -> ResultT m a -> m)
-> (forall a b. (a -> b -> b) -> b -> ResultT m a -> b)
-> (forall a b. (a -> b -> b) -> b -> ResultT m a -> b)
-> (forall b a. (b -> a -> b) -> b -> ResultT m a -> b)
-> (forall b a. (b -> a -> b) -> b -> ResultT m a -> b)
-> (forall a. (a -> a -> a) -> ResultT m a -> a)
-> (forall a. (a -> a -> a) -> ResultT m a -> a)
-> (forall a. ResultT m a -> [a])
-> (forall a. ResultT m a -> Bool)
-> (forall a. ResultT m a -> Int)
-> (forall a. Eq a => a -> ResultT m a -> Bool)
-> (forall a. Ord a => ResultT m a -> a)
-> (forall a. Ord a => ResultT m a -> a)
-> (forall a. Num a => ResultT m a -> a)
-> (forall a. Num a => ResultT m a -> a)
-> Foldable (ResultT m)
forall a. Eq a => a -> ResultT m a -> Bool
forall a. Num a => ResultT m a -> a
forall a. Ord a => ResultT m a -> a
forall m. Monoid m => ResultT m m -> m
forall a. ResultT m a -> Bool
forall a. ResultT m a -> Int
forall a. ResultT m a -> [a]
forall a. (a -> a -> a) -> ResultT m a -> a
forall m a. Monoid m => (a -> m) -> ResultT m a -> m
forall b a. (b -> a -> b) -> b -> ResultT m a -> b
forall a b. (a -> b -> b) -> b -> ResultT m a -> b
forall (m :: * -> *) a.
(Foldable m, Eq a) =>
a -> ResultT m a -> Bool
forall (m :: * -> *) a. (Foldable m, Num a) => ResultT m a -> a
forall (m :: * -> *) a. (Foldable m, Ord a) => ResultT m a -> a
forall (m :: * -> *) m. (Foldable m, Monoid m) => ResultT m m -> m
forall (m :: * -> *) a. Foldable m => ResultT m a -> Bool
forall (m :: * -> *) a. Foldable m => ResultT m a -> Int
forall (m :: * -> *) a. Foldable m => ResultT m a -> [a]
forall (m :: * -> *) a.
Foldable m =>
(a -> a -> a) -> ResultT m a -> a
forall (m :: * -> *) m a.
(Foldable m, Monoid m) =>
(a -> m) -> ResultT m a -> m
forall (m :: * -> *) b a.
Foldable m =>
(b -> a -> b) -> b -> ResultT m a -> b
forall (m :: * -> *) a b.
Foldable m =>
(a -> b -> b) -> b -> ResultT m a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall (m :: * -> *) m. (Foldable m, Monoid m) => ResultT m m -> m
fold :: forall m. Monoid m => ResultT m m -> m
$cfoldMap :: forall (m :: * -> *) m a.
(Foldable m, Monoid m) =>
(a -> m) -> ResultT m a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ResultT m a -> m
$cfoldMap' :: forall (m :: * -> *) m a.
(Foldable m, Monoid m) =>
(a -> m) -> ResultT m a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ResultT m a -> m
$cfoldr :: forall (m :: * -> *) a b.
Foldable m =>
(a -> b -> b) -> b -> ResultT m a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ResultT m a -> b
$cfoldr' :: forall (m :: * -> *) a b.
Foldable m =>
(a -> b -> b) -> b -> ResultT m a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ResultT m a -> b
$cfoldl :: forall (m :: * -> *) b a.
Foldable m =>
(b -> a -> b) -> b -> ResultT m a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ResultT m a -> b
$cfoldl' :: forall (m :: * -> *) b a.
Foldable m =>
(b -> a -> b) -> b -> ResultT m a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ResultT m a -> b
$cfoldr1 :: forall (m :: * -> *) a.
Foldable m =>
(a -> a -> a) -> ResultT m a -> a
foldr1 :: forall a. (a -> a -> a) -> ResultT m a -> a
$cfoldl1 :: forall (m :: * -> *) a.
Foldable m =>
(a -> a -> a) -> ResultT m a -> a
foldl1 :: forall a. (a -> a -> a) -> ResultT m a -> a
$ctoList :: forall (m :: * -> *) a. Foldable m => ResultT m a -> [a]
toList :: forall a. ResultT m a -> [a]
$cnull :: forall (m :: * -> *) a. Foldable m => ResultT m a -> Bool
null :: forall a. ResultT m a -> Bool
$clength :: forall (m :: * -> *) a. Foldable m => ResultT m a -> Int
length :: forall a. ResultT m a -> Int
$celem :: forall (m :: * -> *) a.
(Foldable m, Eq a) =>
a -> ResultT m a -> Bool
elem :: forall a. Eq a => a -> ResultT m a -> Bool
$cmaximum :: forall (m :: * -> *) a. (Foldable m, Ord a) => ResultT m a -> a
maximum :: forall a. Ord a => ResultT m a -> a
$cminimum :: forall (m :: * -> *) a. (Foldable m, Ord a) => ResultT m a -> a
minimum :: forall a. Ord a => ResultT m a -> a
$csum :: forall (m :: * -> *) a. (Foldable m, Num a) => ResultT m a -> a
sum :: forall a. Num a => ResultT m a -> a
$cproduct :: forall (m :: * -> *) a. (Foldable m, Num a) => ResultT m a -> a
product :: forall a. Num a => ResultT m a -> a
Foldable, Functor (ResultT m)
Foldable (ResultT m)
(Functor (ResultT m), Foldable (ResultT m)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ResultT m a -> f (ResultT m b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ResultT m (f a) -> f (ResultT m a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ResultT m a -> m (ResultT m b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ResultT m (m a) -> m (ResultT m a))
-> Traversable (ResultT m)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *). Traversable m => Functor (ResultT m)
forall (m :: * -> *). Traversable m => Foldable (ResultT m)
forall (m :: * -> *) (m :: * -> *) a.
(Traversable m, Monad m) =>
ResultT m (m a) -> m (ResultT m a)
forall (m :: * -> *) (f :: * -> *) a.
(Traversable m, Applicative f) =>
ResultT m (f a) -> f (ResultT m a)
forall (m :: * -> *) (m :: * -> *) a b.
(Traversable m, Monad m) =>
(a -> m b) -> ResultT m a -> m (ResultT m b)
forall (m :: * -> *) (f :: * -> *) a b.
(Traversable m, Applicative f) =>
(a -> f b) -> ResultT m a -> f (ResultT m b)
forall (m :: * -> *) a.
Monad m =>
ResultT m (m a) -> m (ResultT m a)
forall (f :: * -> *) a.
Applicative f =>
ResultT m (f a) -> f (ResultT m a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ResultT m a -> m (ResultT m b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ResultT m a -> f (ResultT m b)
$ctraverse :: forall (m :: * -> *) (f :: * -> *) a b.
(Traversable m, Applicative f) =>
(a -> f b) -> ResultT m a -> f (ResultT m b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ResultT m a -> f (ResultT m b)
$csequenceA :: forall (m :: * -> *) (f :: * -> *) a.
(Traversable m, Applicative f) =>
ResultT m (f a) -> f (ResultT m a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ResultT m (f a) -> f (ResultT m a)
$cmapM :: forall (m :: * -> *) (m :: * -> *) a b.
(Traversable m, Monad m) =>
(a -> m b) -> ResultT m a -> m (ResultT m b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ResultT m a -> m (ResultT m b)
$csequence :: forall (m :: * -> *) (m :: * -> *) a.
(Traversable m, Monad m) =>
ResultT m (m a) -> m (ResultT m a)
sequence :: forall (m :: * -> *) a.
Monad m =>
ResultT m (m a) -> m (ResultT m a)
Traversable)
  deriving newtype ((forall a. Eq a => Eq (ResultT m a)) =>
(forall a b.
 (a -> b -> Bool) -> ResultT m a -> ResultT m b -> Bool)
-> Eq1 (ResultT m)
forall a. Eq a => Eq (ResultT m a)
forall a b. (a -> b -> Bool) -> ResultT m a -> ResultT m b -> Bool
forall (m :: * -> *) a. (Eq1 m, Eq a) => Eq (ResultT m a)
forall (m :: * -> *) a b.
Eq1 m =>
(a -> b -> Bool) -> ResultT m a -> ResultT m b -> Bool
forall (f :: * -> *).
(forall a. Eq a => Eq (f a)) =>
(forall a b. (a -> b -> Bool) -> f a -> f b -> Bool) -> Eq1 f
$cliftEq :: forall (m :: * -> *) a b.
Eq1 m =>
(a -> b -> Bool) -> ResultT m a -> ResultT m b -> Bool
liftEq :: forall a b. (a -> b -> Bool) -> ResultT m a -> ResultT m b -> Bool
Eq1, Eq1 (ResultT m)
(Eq1 (ResultT m), forall a. Ord a => Ord (ResultT m a)) =>
(forall a b.
 (a -> b -> Ordering) -> ResultT m a -> ResultT m b -> Ordering)
-> Ord1 (ResultT m)
forall a. Ord a => Ord (ResultT m a)
forall a b.
(a -> b -> Ordering) -> ResultT m a -> ResultT m b -> Ordering
forall (m :: * -> *). Ord1 m => Eq1 (ResultT m)
forall (m :: * -> *) a. (Ord1 m, Ord a) => Ord (ResultT m a)
forall (m :: * -> *) a b.
Ord1 m =>
(a -> b -> Ordering) -> ResultT m a -> ResultT m b -> Ordering
forall (f :: * -> *).
(Eq1 f, forall a. Ord a => Ord (f a)) =>
(forall a b. (a -> b -> Ordering) -> f a -> f b -> Ordering)
-> Ord1 f
$cliftCompare :: forall (m :: * -> *) a b.
Ord1 m =>
(a -> b -> Ordering) -> ResultT m a -> ResultT m b -> Ordering
liftCompare :: forall a b.
(a -> b -> Ordering) -> ResultT m a -> ResultT m b -> Ordering
Ord1, Functor (ResultT m)
Functor (ResultT m) =>
(forall a. a -> ResultT m a)
-> (forall a b. ResultT m (a -> b) -> ResultT m a -> ResultT m b)
-> (forall a b c.
    (a -> b -> c) -> ResultT m a -> ResultT m b -> ResultT m c)
-> (forall a b. ResultT m a -> ResultT m b -> ResultT m b)
-> (forall a b. ResultT m a -> ResultT m b -> ResultT m a)
-> Applicative (ResultT m)
forall a. a -> ResultT m a
forall a b. ResultT m a -> ResultT m b -> ResultT m a
forall a b. ResultT m a -> ResultT m b -> ResultT m b
forall a b. ResultT m (a -> b) -> ResultT m a -> ResultT m b
forall a b c.
(a -> b -> c) -> ResultT m a -> ResultT m b -> ResultT m c
forall (m :: * -> *). Monad m => Functor (ResultT m)
forall (m :: * -> *) a. Monad m => a -> ResultT m a
forall (m :: * -> *) a b.
Monad m =>
ResultT m a -> ResultT m b -> ResultT m a
forall (m :: * -> *) a b.
Monad m =>
ResultT m a -> ResultT m b -> ResultT m b
forall (m :: * -> *) a b.
Monad m =>
ResultT m (a -> b) -> ResultT m a -> ResultT m b
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> c) -> ResultT m a -> ResultT m b -> ResultT m c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall (m :: * -> *) a. Monad m => a -> ResultT m a
pure :: forall a. a -> ResultT m a
$c<*> :: forall (m :: * -> *) a b.
Monad m =>
ResultT m (a -> b) -> ResultT m a -> ResultT m b
<*> :: forall a b. ResultT m (a -> b) -> ResultT m a -> ResultT m b
$cliftA2 :: forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> c) -> ResultT m a -> ResultT m b -> ResultT m c
liftA2 :: forall a b c.
(a -> b -> c) -> ResultT m a -> ResultT m b -> ResultT m c
$c*> :: forall (m :: * -> *) a b.
Monad m =>
ResultT m a -> ResultT m b -> ResultT m b
*> :: forall a b. ResultT m a -> ResultT m b -> ResultT m b
$c<* :: forall (m :: * -> *) a b.
Monad m =>
ResultT m a -> ResultT m b -> ResultT m a
<* :: forall a b. ResultT m a -> ResultT m b -> ResultT m a
Applicative, Applicative (ResultT m)
Applicative (ResultT m) =>
(forall a. ResultT m a)
-> (forall a. ResultT m a -> ResultT m a -> ResultT m a)
-> (forall a. ResultT m a -> ResultT m [a])
-> (forall a. ResultT m a -> ResultT m [a])
-> Alternative (ResultT m)
forall a. ResultT m a
forall a. ResultT m a -> ResultT m [a]
forall a. ResultT m a -> ResultT m a -> ResultT m a
forall (m :: * -> *). Monad m => Applicative (ResultT m)
forall (m :: * -> *) a. Monad m => ResultT m a
forall (m :: * -> *) a. Monad m => ResultT m a -> ResultT m [a]
forall (m :: * -> *) a.
Monad m =>
ResultT m a -> ResultT m a -> ResultT m a
forall (f :: * -> *).
Applicative f =>
(forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
$cempty :: forall (m :: * -> *) a. Monad m => ResultT m a
empty :: forall a. ResultT m a
$c<|> :: forall (m :: * -> *) a.
Monad m =>
ResultT m a -> ResultT m a -> ResultT m a
<|> :: forall a. ResultT m a -> ResultT m a -> ResultT m a
$csome :: forall (m :: * -> *) a. Monad m => ResultT m a -> ResultT m [a]
some :: forall a. ResultT m a -> ResultT m [a]
$cmany :: forall (m :: * -> *) a. Monad m => ResultT m a -> ResultT m [a]
many :: forall a. ResultT m a -> ResultT m [a]
Alternative, Applicative (ResultT m)
Applicative (ResultT m) =>
(forall a b. ResultT m a -> (a -> ResultT m b) -> ResultT m b)
-> (forall a b. ResultT m a -> ResultT m b -> ResultT m b)
-> (forall a. a -> ResultT m a)
-> Monad (ResultT m)
forall a. a -> ResultT m a
forall a b. ResultT m a -> ResultT m b -> ResultT m b
forall a b. ResultT m a -> (a -> ResultT m b) -> ResultT m b
forall (m :: * -> *). Monad m => Applicative (ResultT m)
forall (m :: * -> *) a. Monad m => a -> ResultT m a
forall (m :: * -> *) a b.
Monad m =>
ResultT m a -> ResultT m b -> ResultT m b
forall (m :: * -> *) a b.
Monad m =>
ResultT m a -> (a -> ResultT m b) -> ResultT m b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
ResultT m a -> (a -> ResultT m b) -> ResultT m b
>>= :: forall a b. ResultT m a -> (a -> ResultT m b) -> ResultT m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
ResultT m a -> ResultT m b -> ResultT m b
>> :: forall a b. ResultT m a -> ResultT m b -> ResultT m b
$creturn :: forall (m :: * -> *) a. Monad m => a -> ResultT m a
return :: forall a. a -> ResultT m a
Monad, (forall (m :: * -> *). Monad m => Monad (ResultT m)) =>
(forall (m :: * -> *) a. Monad m => m a -> ResultT m a)
-> MonadTrans ResultT
forall (m :: * -> *). Monad m => Monad (ResultT m)
forall (m :: * -> *) a. Monad m => m a -> ResultT m a
forall (t :: (* -> *) -> * -> *).
(forall (m :: * -> *). Monad m => Monad (t m)) =>
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
$clift :: forall (m :: * -> *) a. Monad m => m a -> ResultT m a
lift :: forall (m :: * -> *) a. Monad m => m a -> ResultT m a
MonadTrans, Monad (ResultT m)
Monad (ResultT m) =>
(forall a. (a -> ResultT m a) -> ResultT m a)
-> MonadFix (ResultT m)
forall a. (a -> ResultT m a) -> ResultT m a
forall (m :: * -> *).
Monad m =>
(forall a. (a -> m a) -> m a) -> MonadFix m
forall (m :: * -> *). MonadFix m => Monad (ResultT m)
forall (m :: * -> *) a.
MonadFix m =>
(a -> ResultT m a) -> ResultT m a
$cmfix :: forall (m :: * -> *) a.
MonadFix m =>
(a -> ResultT m a) -> ResultT m a
mfix :: forall a. (a -> ResultT m a) -> ResultT m a
MonadFix, Monad (ResultT m)
Monad (ResultT m) =>
(forall a b. ResultT m a -> ResultT m b -> ResultT m (a, b))
-> (forall a b c.
    (a -> b -> c) -> ResultT m a -> ResultT m b -> ResultT m c)
-> (forall a b. ResultT m (a, b) -> (ResultT m a, ResultT m b))
-> MonadZip (ResultT m)
forall a b. ResultT m a -> ResultT m b -> ResultT m (a, b)
forall a b. ResultT m (a, b) -> (ResultT m a, ResultT m b)
forall a b c.
(a -> b -> c) -> ResultT m a -> ResultT m b -> ResultT m c
forall (m :: * -> *).
Monad m =>
(forall a b. m a -> m b -> m (a, b))
-> (forall a b c. (a -> b -> c) -> m a -> m b -> m c)
-> (forall a b. m (a, b) -> (m a, m b))
-> MonadZip m
forall (m :: * -> *). MonadZip m => Monad (ResultT m)
forall (m :: * -> *) a b.
MonadZip m =>
ResultT m a -> ResultT m b -> ResultT m (a, b)
forall (m :: * -> *) a b.
MonadZip m =>
ResultT m (a, b) -> (ResultT m a, ResultT m b)
forall (m :: * -> *) a b c.
MonadZip m =>
(a -> b -> c) -> ResultT m a -> ResultT m b -> ResultT m c
$cmzip :: forall (m :: * -> *) a b.
MonadZip m =>
ResultT m a -> ResultT m b -> ResultT m (a, b)
mzip :: forall a b. ResultT m a -> ResultT m b -> ResultT m (a, b)
$cmzipWith :: forall (m :: * -> *) a b c.
MonadZip m =>
(a -> b -> c) -> ResultT m a -> ResultT m b -> ResultT m c
mzipWith :: forall a b c.
(a -> b -> c) -> ResultT m a -> ResultT m b -> ResultT m c
$cmunzip :: forall (m :: * -> *) a b.
MonadZip m =>
ResultT m (a, b) -> (ResultT m a, ResultT m b)
munzip :: forall a b. ResultT m (a, b) -> (ResultT m a, ResultT m b)
MonadZip, Monad (ResultT m)
Monad (ResultT m) =>
(forall a. IO a -> ResultT m a) -> MonadIO (ResultT m)
forall a. IO a -> ResultT m a
forall (m :: * -> *).
Monad m =>
(forall a. IO a -> m a) -> MonadIO m
forall (m :: * -> *). MonadIO m => Monad (ResultT m)
forall (m :: * -> *) a. MonadIO m => IO a -> ResultT m a
$cliftIO :: forall (m :: * -> *) a. MonadIO m => IO a -> ResultT m a
liftIO :: forall a. IO a -> ResultT m a
MonadIO, Monad (ResultT m)
Alternative (ResultT m)
(Alternative (ResultT m), Monad (ResultT m)) =>
(forall a. ResultT m a)
-> (forall a. ResultT m a -> ResultT m a -> ResultT m a)
-> MonadPlus (ResultT m)
forall a. ResultT m a
forall a. ResultT m a -> ResultT m a -> ResultT m a
forall (m :: * -> *). Monad m => Monad (ResultT m)
forall (m :: * -> *). Monad m => Alternative (ResultT m)
forall (m :: * -> *) a. Monad m => ResultT m a
forall (m :: * -> *) a.
Monad m =>
ResultT m a -> ResultT m a -> ResultT m a
forall (m :: * -> *).
(Alternative m, Monad m) =>
(forall a. m a) -> (forall a. m a -> m a -> m a) -> MonadPlus m
$cmzero :: forall (m :: * -> *) a. Monad m => ResultT m a
mzero :: forall a. ResultT m a
$cmplus :: forall (m :: * -> *) a.
Monad m =>
ResultT m a -> ResultT m a -> ResultT m a
mplus :: forall a. ResultT m a -> ResultT m a -> ResultT m a
MonadPlus, Monad (ResultT m)
Monad (ResultT m) =>
(forall a b. ((a -> ResultT m b) -> ResultT m a) -> ResultT m a)
-> MonadCont (ResultT m)
forall a b. ((a -> ResultT m b) -> ResultT m a) -> ResultT m a
forall (m :: * -> *).
Monad m =>
(forall a b. ((a -> m b) -> m a) -> m a) -> MonadCont m
forall (m :: * -> *). MonadCont m => Monad (ResultT m)
forall (m :: * -> *) a b.
MonadCont m =>
((a -> ResultT m b) -> ResultT m a) -> ResultT m a
$ccallCC :: forall (m :: * -> *) a b.
MonadCont m =>
((a -> ResultT m b) -> ResultT m a) -> ResultT m a
callCC :: forall a b. ((a -> ResultT m b) -> ResultT m a) -> ResultT m a
MonadCont, MonadRWS r w s, MonadReader r, MonadState s, MonadWriter w, (forall a' a. (a' -> a) -> ResultT m a -> ResultT m a')
-> (forall b a. b -> ResultT m b -> ResultT m a)
-> Contravariant (ResultT m)
forall b a. b -> ResultT m b -> ResultT m a
forall a' a. (a' -> a) -> ResultT m a -> ResultT m a'
forall (m :: * -> *) b a.
Contravariant m =>
b -> ResultT m b -> ResultT m a
forall (m :: * -> *) a' a.
Contravariant m =>
(a' -> a) -> ResultT m a -> ResultT m a'
forall (f :: * -> *).
(forall a' a. (a' -> a) -> f a -> f a')
-> (forall b a. b -> f b -> f a) -> Contravariant f
$ccontramap :: forall (m :: * -> *) a' a.
Contravariant m =>
(a' -> a) -> ResultT m a -> ResultT m a'
contramap :: forall a' a. (a' -> a) -> ResultT m a -> ResultT m a'
$c>$ :: forall (m :: * -> *) b a.
Contravariant m =>
b -> ResultT m b -> ResultT m a
>$ :: forall b a. b -> ResultT m b -> ResultT m a
Contravariant)

instance Read1 m => Read1 (ResultT m) where
  liftReadPrec :: forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (ResultT m a)
liftReadPrec ReadPrec a
rp ReadPrec [a]
rl =
    ReadPrec (ResultT m a) -> ReadPrec (ResultT m a)
forall a. ReadPrec a -> ReadPrec a
readData (ReadPrec (ResultT m a) -> ReadPrec (ResultT m a))
-> ReadPrec (ResultT m a) -> ReadPrec (ResultT m a)
forall a b. (a -> b) -> a -> b
$
      ReadPrec (ExceptT String m a)
-> String
-> (ExceptT String m a -> ResultT m a)
-> ReadPrec (ResultT m a)
forall a t. ReadPrec a -> String -> (a -> t) -> ReadPrec t
readUnaryWith (ReadPrec a -> ReadPrec [a] -> ReadPrec (ExceptT String m a)
forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec (ExceptT String m a)
forall (f :: * -> *) a.
Read1 f =>
ReadPrec a -> ReadPrec [a] -> ReadPrec (f a)
liftReadPrec ReadPrec a
rp ReadPrec [a]
rl) String
"ResultT" ExceptT String m a -> ResultT m a
forall (m :: * -> *) a. ExceptT String m a -> ResultT m a
ResultT

instance Show1 m => Show1 (ResultT m) where
  liftShowsPrec :: forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> ResultT m a -> ShowS
liftShowsPrec Int -> a -> ShowS
sp [a] -> ShowS
sl Int
d (ResultT ExceptT String m a
m) =
    (Int -> ExceptT String m a -> ShowS)
-> String -> Int -> ExceptT String m a -> ShowS
forall a. (Int -> a -> ShowS) -> String -> Int -> a -> ShowS
showsUnaryWith ((Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> ExceptT String m a -> ShowS
forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> ExceptT String m a -> ShowS
forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS
liftShowsPrec Int -> a -> ShowS
sp [a] -> ShowS
sl) String
"ResultT" Int
d ExceptT String m a
m

instance Monad m => MonadFail (ResultT m) where
    fail :: forall a. String -> ResultT m a
fail = String -> ResultT m a
forall (m :: * -> *) a. Monad m => String -> ResultT m a
throwE
    {-# INLINE fail #-}

-- | Map the unwrapped computation using the given function.
mapResultT :: (ExceptT String m a -> ExceptT String n b) -> ResultT m a -> ResultT n b
mapResultT :: forall (m :: * -> *) a (n :: * -> *) b.
(ExceptT String m a -> ExceptT String n b)
-> ResultT m a -> ResultT n b
mapResultT ExceptT String m a -> ExceptT String n b
f ResultT m a
m = ExceptT String n b -> ResultT n b
forall (m :: * -> *) a. ExceptT String m a -> ResultT m a
ResultT (ExceptT String n b -> ResultT n b)
-> ExceptT String n b -> ResultT n b
forall a b. (a -> b) -> a -> b
$ (m (Either String a) -> n (Either String b))
-> ExceptT String m a -> ExceptT String n b
forall (m :: * -> *) e a (n :: * -> *) e' b.
(m (Either e a) -> n (Either e' b))
-> ExceptT e m a -> ExceptT e' n b
mapExceptT (ExceptT String n b -> n (Either String b)
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT String n b -> n (Either String b))
-> (m (Either String a) -> ExceptT String n b)
-> m (Either String a)
-> n (Either String b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptT String m a -> ExceptT String n b
f (ExceptT String m a -> ExceptT String n b)
-> (m (Either String a) -> ExceptT String m a)
-> m (Either String a)
-> ExceptT String n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (Either String a) -> ExceptT String m a
forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT) (ExceptT String m a -> ExceptT String n b)
-> ExceptT String m a -> ExceptT String n b
forall a b. (a -> b) -> a -> b
$ ResultT m a -> ExceptT String m a
forall (m :: * -> *) a. ResultT m a -> ExceptT String m a
runResultT ResultT m a
m
{-# INLINE mapResultT #-}

-- | Signal an exception.
throwE :: Monad m => String -> ResultT m a
throwE :: forall (m :: * -> *) a. Monad m => String -> ResultT m a
throwE = ExceptT String m a -> ResultT m a
forall (m :: * -> *) a. ExceptT String m a -> ResultT m a
ResultT (ExceptT String m a -> ResultT m a)
-> (String -> ExceptT String m a) -> String -> ResultT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ExceptT String m a
forall (m :: * -> *) e a. Monad m => e -> ExceptT e m a
Except.throwE
{-# INLINE throwE #-}

-- | Handle an exception.
catchE :: Monad m => ResultT m a -> (String -> ResultT m a) -> ResultT m a
ResultT m a
m catchE :: forall (m :: * -> *) a.
Monad m =>
ResultT m a -> (String -> ResultT m a) -> ResultT m a
`catchE` String -> ResultT m a
h = ExceptT String m a -> ResultT m a
forall (m :: * -> *) a. ExceptT String m a -> ResultT m a
ResultT (ExceptT String m a -> ResultT m a)
-> ExceptT String m a -> ResultT m a
forall a b. (a -> b) -> a -> b
$ ResultT m a -> ExceptT String m a
forall (m :: * -> *) a. ResultT m a -> ExceptT String m a
runResultT ResultT m a
m ExceptT String m a
-> (String -> ExceptT String m a) -> ExceptT String m a
forall (m :: * -> *) e a e'.
Monad m =>
ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a
`Except.catchE` (ResultT m a -> ExceptT String m a
forall (m :: * -> *) a. ResultT m a -> ExceptT String m a
runResultT (ResultT m a -> ExceptT String m a)
-> (String -> ResultT m a) -> String -> ExceptT String m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ResultT m a
h)
{-# INLINE catchE #-}

-- | Lift a @callCC@ operation to the new monad.
liftCallCC :: CallCC m (Either String a) (Either String b) -> CallCC (ResultT m) a b
liftCallCC :: forall (m :: * -> *) a b.
CallCC m (Either String a) (Either String b)
-> CallCC (ResultT m) a b
liftCallCC CallCC m (Either String a) (Either String b)
callCC (a -> ResultT m b) -> ResultT m a
f = ExceptT String m a -> ResultT m a
forall (m :: * -> *) a. ExceptT String m a -> ResultT m a
ResultT (ExceptT String m a -> ResultT m a)
-> ExceptT String m a -> ResultT m a
forall a b. (a -> b) -> a -> b
$ CallCC m (Either String a) (Either String b)
-> CallCC (ExceptT String m) a b
forall (m :: * -> *) e a b.
CallCC m (Either e a) (Either e b) -> CallCC (ExceptT e m) a b
Except.liftCallCC CallCC m (Either String a) (Either String b)
callCC CallCC (ExceptT String m) a b -> CallCC (ExceptT String m) a b
forall a b. (a -> b) -> a -> b
$ \a -> ExceptT String m b
c -> ResultT m a -> ExceptT String m a
forall (m :: * -> *) a. ResultT m a -> ExceptT String m a
runResultT (ResultT m a -> ExceptT String m a)
-> ResultT m a -> ExceptT String m a
forall a b. (a -> b) -> a -> b
$ (a -> ResultT m b) -> ResultT m a
f ((a -> ResultT m b) -> ResultT m a)
-> (a -> ResultT m b) -> ResultT m a
forall a b. (a -> b) -> a -> b
$ ExceptT String m b -> ResultT m b
forall (m :: * -> *) a. ExceptT String m a -> ResultT m a
ResultT (ExceptT String m b -> ResultT m b)
-> (a -> ExceptT String m b) -> a -> ResultT m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ExceptT String m b
c
{-# INLINE liftCallCC #-}

-- | Lift a @listen@ operation to the new monad.
liftListen :: Monad m => Listen w m (Either String a) -> Listen w (ResultT m) a
liftListen :: forall (m :: * -> *) w a.
Monad m =>
Listen w m (Either String a) -> Listen w (ResultT m) a
liftListen Listen w m (Either String a)
listen = ExceptT String m (a, w) -> ResultT m (a, w)
forall (m :: * -> *) a. ExceptT String m a -> ResultT m a
ResultT (ExceptT String m (a, w) -> ResultT m (a, w))
-> (ResultT m a -> ExceptT String m (a, w))
-> ResultT m a
-> ResultT m (a, w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Listen w m (Either String a) -> Listen w (ExceptT String m) a
forall (m :: * -> *) w e a.
Monad m =>
Listen w m (Either e a) -> Listen w (ExceptT e m) a
Except.liftListen Listen w m (Either String a)
listen Listen w (ExceptT String m) a
-> (ResultT m a -> ExceptT String m a)
-> ResultT m a
-> ExceptT String m (a, w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResultT m a -> ExceptT String m a
forall (m :: * -> *) a. ResultT m a -> ExceptT String m a
runResultT
{-# INLINE liftListen #-}

-- | Lift a @pass@ operation to the new monad.
liftPass :: Monad m => Pass w m (Either String a) -> Pass w (ResultT m) a
liftPass :: forall (m :: * -> *) w a.
Monad m =>
Pass w m (Either String a) -> Pass w (ResultT m) a
liftPass Pass w m (Either String a)
pass = ExceptT String m a -> ResultT m a
forall (m :: * -> *) a. ExceptT String m a -> ResultT m a
ResultT (ExceptT String m a -> ResultT m a)
-> (ResultT m (a, w -> w) -> ExceptT String m a)
-> ResultT m (a, w -> w)
-> ResultT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pass w m (Either String a) -> Pass w (ExceptT String m) a
forall (m :: * -> *) w e a.
Monad m =>
Pass w m (Either e a) -> Pass w (ExceptT e m) a
Except.liftPass Pass w m (Either String a)
pass Pass w (ExceptT String m) a
-> (ResultT m (a, w -> w) -> ExceptT String m (a, w -> w))
-> ResultT m (a, w -> w)
-> ExceptT String m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResultT m (a, w -> w) -> ExceptT String m (a, w -> w)
forall (m :: * -> *) a. ResultT m a -> ExceptT String m a
runResultT
{-# INLINE liftPass #-}