Module

Effect.Postgres.Error.RE

Package: purescript-postgresql
Repository: cakekindel/purescript-postgresql

#RE Source

newtype RE :: Type -> (Type -> Type) -> Type -> Typenewtype RE r m a

ReaderT with ExceptT E

ReaderT r (ExceptT (NonEmptyList Effect.Postgres.Error.Error) m) a

Constructors

RE (ReaderT r (ExceptT E m) a)

Instances

Newtype (RE r m a) _
(Monad m) => MonadAsk r (RE r m)
(Monad m) => MonadReader r (RE r m)
(Monad m) => Functor (RE r m)
(Monad m) => Apply (RE r m)
(Monad m) => Applicative (RE r m)
(Monad m) => Bind (RE r m)
(Monad m) => Monad (RE r m)
(Monad m) => MonadError E (RE r m)
(Monad m) => MonadThrow E (RE r m)
(MonadRec m) => MonadRec (RE r m)
(MonadEffect m) => MonadEffect (RE r m)
(MonadAff m) => MonadAff (RE r m)
(Monad m, Parallel p m) => Parallel (ParRE r p) (RE r m)
MonadTrans (RE r)
MFunctor (RE r)
MMonad (RE r)
(Monad m) => Alt (RE r m)
(MonadThrow Error m, MonadUnliftEffect m) => MonadUnliftEffect (RE r m)
(MonadThrow Error m, MonadUnliftAff m) => MonadUnliftAff (RE r m)
(MonadBase m (RE r m), MonadThrow Error m) => MonadUnlift m (RE r m)
(Monad m) => MonadBase m (RE r m)
(MonadThrow Error m, MonadFork f m) => MonadFork (Compose f (Either E)) (RE r m)
(MonadKill Error f m) => MonadKill E (Compose f (Either E)) (RE r m)
(MonadEffect m, MonadBracket Error f m) => MonadBracket E (Compose f (Either E)) (RE r m)

#ParRE Source

newtype ParRE :: Type -> (Type -> Type) -> Type -> Typenewtype ParRE r f a

Constructors

ParRE (ReaderT r (Compose f (Either E)) a)

Instances

Newtype (ParRE r m a) _
(Functor m) => Functor (ParRE r m)
(Apply m) => Apply (ParRE r m)
(Applicative m) => Applicative (ParRE r m)
(Alt m) => Alt (ParRE r m)
(Plus m) => Plus (ParRE r m)
(Alternative m) => Alternative (ParRE r m)
(Monad m, Parallel p m) => Parallel (ParRE r p) (RE r m)

#finally Source

finally :: forall r m a. Monad m => RE r m Unit -> RE r m a -> RE r m a

#run Source

run :: forall m r a. MonadThrow Error m => RE r m a -> r -> m a

#toExcept Source

toExcept :: forall m r a. RE r m a -> r -> Except m a

#toEither Source

toEither :: forall m r a. RE r m a -> r -> m (Either E a)

#liftExcept Source

liftExcept :: forall m r a. Monad m => Except m a -> RE r m a