Haskus.Utils.Variant.Flow

Documentation

type Flow es = FlowT es Identity

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

FlowT

data FlowT es m a

Instances

MonadTrans (FlowT e)

Defined in Haskus.Utils.Variant.Flow

Methods

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

Monad m => Monad (FlowT es m)

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)

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)

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)

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)

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)

Defined in Haskus.Utils.Variant.Flow

Methods

liftIO :: IO a -> FlowT es m a

MonadThrow m => MonadThrow (FlowT e m)

Throws exceptions into the base monad.

Defined in Haskus.Utils.Variant.Flow

Methods

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

MonadCatch m => MonadCatch (FlowT e m)

Catches exceptions from the base monad.

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)

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)

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)

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))

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

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

Convert a flow without error into a value

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

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

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

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

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

Lift a FlowT into another

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

Convert a Variant into a FlowT

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

Success value

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

Signal an exception value e.

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

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

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

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

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

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

Do something in case of error

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

Catch and die in case of error

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

Handle an exception. Assume it is in the first position

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

Do something in case of error

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

Do something in case of error

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

Finally for FlowT

Reexport

module Haskus.Utils.Variant