haskus-utils-variant-2.6.1: Variant and EADT

Safe HaskellNone
LanguageHaskell2010

Haskus.Utils.Variant.Flow

Contents

Synopsis

Documentation

type Flow es = FlowT es Identity Source #

runFlow :: Flow es a -> V (a ': es) Source #

FlowT

data FlowT es m a Source #

Instances
MonadTrans (FlowT e) Source # 
Instance details

Defined in Haskus.Utils.Variant.Flow

Methods

lift :: Monad m => m a -> FlowT e m a #

Monad m => Monad (FlowT es m) Source # 
Instance details

Defined in Haskus.Utils.Variant.Flow

Methods

(>>=) :: FlowT es m a -> (a -> FlowT es m b) -> FlowT es m b #

(>>) :: FlowT es m a -> FlowT es m b -> FlowT es m b #

return :: a -> FlowT es m a #

fail :: String -> FlowT es m a #

Functor m => Functor (FlowT es m) Source # 
Instance details

Defined in Haskus.Utils.Variant.Flow

Methods

fmap :: (a -> b) -> FlowT es m a -> FlowT es m b #

(<$) :: a -> FlowT es m b -> FlowT es m a #

(Functor m, Monad m) => Applicative (FlowT es m) Source # 
Instance details

Defined in Haskus.Utils.Variant.Flow

Methods

pure :: a -> FlowT es m a #

(<*>) :: FlowT es m (a -> b) -> FlowT es m a -> FlowT es m b #

liftA2 :: (a -> b -> c) -> FlowT es m a -> FlowT es m b -> FlowT es m c #

(*>) :: FlowT es m a -> FlowT es m b -> FlowT es m b #

(<*) :: FlowT es m a -> FlowT es m b -> FlowT es m a #

Foldable m => Foldable (FlowT es m) Source # 
Instance details

Defined in Haskus.Utils.Variant.Flow

Methods

fold :: Monoid m0 => FlowT es m m0 -> m0 #

foldMap :: Monoid m0 => (a -> m0) -> FlowT es m a -> m0 #

foldr :: (a -> b -> b) -> b -> FlowT es m a -> b #

foldr' :: (a -> b -> b) -> b -> FlowT es m a -> b #

foldl :: (b -> a -> b) -> b -> FlowT es m a -> b #

foldl' :: (b -> a -> b) -> b -> FlowT es m a -> b #

foldr1 :: (a -> a -> a) -> FlowT es m a -> a #

foldl1 :: (a -> a -> a) -> FlowT es m a -> a #

toList :: FlowT es m a -> [a] #

null :: FlowT es m a -> Bool #

length :: FlowT es m a -> Int #

elem :: Eq a => a -> FlowT es m a -> Bool #

maximum :: Ord a => FlowT es m a -> a #

minimum :: Ord a => FlowT es m a -> a #

sum :: Num a => FlowT es m a -> a #

product :: Num a => FlowT es m a -> a #

Traversable m => Traversable (FlowT es m) Source # 
Instance details

Defined in Haskus.Utils.Variant.Flow

Methods

traverse :: Applicative f => (a -> f b) -> FlowT es m a -> f (FlowT es m b) #

sequenceA :: Applicative f => FlowT es m (f a) -> f (FlowT es m a) #

mapM :: Monad m0 => (a -> m0 b) -> FlowT es m a -> m0 (FlowT es m b) #

sequence :: Monad m0 => FlowT es m (m0 a) -> m0 (FlowT es m a) #

MonadIO m => MonadIO (FlowT es m) Source # 
Instance details

Defined in Haskus.Utils.Variant.Flow

Methods

liftIO :: IO a -> FlowT es m a #

MonadThrow m => MonadThrow (FlowT e m) Source #

Throws exceptions into the base monad.

Instance details

Defined in Haskus.Utils.Variant.Flow

Methods

throwM :: Exception e0 => e0 -> FlowT e m a #

MonadCatch m => MonadCatch (FlowT e m) Source #

Catches exceptions from the base monad.

Instance details

Defined in Haskus.Utils.Variant.Flow

Methods

catch :: Exception e0 => FlowT e m a -> (e0 -> FlowT e m a) -> FlowT e m a #

MonadMask m => MonadMask (FlowT e m) Source # 
Instance details

Defined in Haskus.Utils.Variant.Flow

Methods

mask :: ((forall a. FlowT e m a -> FlowT e m a) -> FlowT e m b) -> FlowT e m b #

uninterruptibleMask :: ((forall a. FlowT e m a -> FlowT e m a) -> FlowT e m b) -> FlowT e m b #

generalBracket :: FlowT e m a -> (a -> ExitCase b -> FlowT e m c) -> (a -> FlowT e m b) -> FlowT e m (b, c) #

MonadInIO m => MonadInIO (FlowT es m) Source # 
Instance details

Defined in Haskus.Utils.Variant.Flow

Methods

liftWith :: (forall c. (a -> IO c) -> IO c) -> (a -> FlowT es m b) -> FlowT es m b #

liftWith2 :: (forall c. (a -> b -> IO c) -> IO c) -> (a -> b -> FlowT es m e) -> FlowT es m e #

Show (m (V (a ': es))) => Show (FlowT es m a) Source # 
Instance details

Defined in Haskus.Utils.Variant.Flow

Methods

showsPrec :: Int -> FlowT es m a -> ShowS #

show :: FlowT es m a -> String #

showList :: [FlowT es m a] -> ShowS #

runFlowT :: FlowT es m a -> m (V (a ': es)) Source #

runFlowT_ :: Functor m => FlowT es m a -> m () Source #

evalFlowT :: Monad m => FlowT '[] m a -> m a Source #

Convert a flow without error into a value

evalCatchFlowT :: Monad m => (V es -> m a) -> FlowT es m a -> m a Source #

Evaluate a FlowT. Use the provided function to handle error cases.

injectFlowT :: Monad m => FlowT es m a -> FlowT es m (V (a ': es)) Source #

mapFlowT :: (m (V (a ': es)) -> n (V (b ': es'))) -> FlowT es m a -> FlowT es' n b Source #

liftFlowT :: (Monad m, LiftVariant es es') => FlowT es m a -> FlowT es' m a Source #

Lift a FlowT into another

variantToFlowT :: Monad m => V (a ': es) -> FlowT es m a Source #

Convert a Variant into a FlowT

success :: Monad m => a -> FlowT '[] m a Source #

Success value

failure :: Monad m => e -> FlowT '[e] m a Source #

Signal an exception value e.

throwE :: (Monad m, e :< es) => e -> FlowT es m a Source #

Signal an exception value e.

catchE :: forall e es' es'' es a m. (Monad m, e :< es, LiftVariant (Remove e es) es', LiftVariant es'' es') => FlowT es m a -> (e -> FlowT es'' m a) -> FlowT es' m a Source #

Handle an exception. Lift both normal and exceptional flows into the result flow

catchLiftBoth :: forall e es' es'' es a m. (Monad m, e :< es, LiftVariant (Remove e es) es', LiftVariant es'' es') => FlowT es m a -> (e -> FlowT es'' m a) -> FlowT es' m a Source #

Handle an exception. Lift both normal and exceptional flows into the result flow

catchLiftLeft :: forall e es es' a m. (Monad m, e :< es, LiftVariant (Remove e es) es') => FlowT es m a -> (e -> FlowT es' m a) -> FlowT es' m a Source #

Handle an exception. Lift the remaining errors into the resulting flow

catchLiftRight :: forall e es es' a m. (Monad m, e :< es, LiftVariant es' (Remove e es)) => FlowT es m a -> (e -> FlowT es' m a) -> FlowT (Remove e es) m a Source #

Handle an exception. Lift the handler into the resulting flow

catchAllE :: Monad m => FlowT es m a -> (V es -> FlowT es' m a) -> FlowT es' m a Source #

Do something in case of error

catchDie :: (e :< es, Monad m) => FlowT es m a -> (e -> m ()) -> FlowT (Remove e es) m a Source #

Catch and die in case of error

catchDieAll :: Monad m => FlowT es m a -> (V es -> m a) -> m a Source #

Evaluate a FlowT. Use the provided function to handle error cases.

catchRemove :: forall e es a m. Monad m => FlowT (e ': es) m a -> (e -> FlowT es m a) -> FlowT es m a Source #

Handle an exception. Assume it is in the first position

onFlowError_ :: Monad m => FlowT es m a -> m () -> FlowT es m a Source #

Do something in case of error

onFlowError :: Monad m => FlowT es m a -> (V es -> m ()) -> FlowT es m a Source #

Do something in case of error

finallyFlow :: Monad m => FlowT es m a -> m () -> FlowT es m a Source #

Finally for FlowT

Reexport