Safe Haskell	None
Language	Haskell2010

Control.Effect.Resumable

Synopsis

data Resumable err (m :: * -> *) k = Resumable (err a) (a -> k)
throwResumable :: (Member (Resumable err) sig, Carrier sig m) => err a -> m a
data SomeError (err :: * -> *) = SomeError (err a)
runResumable :: (Carrier sig m, Effect sig) => Eff (ResumableC err m) a -> m (Either (SomeError err) a)
newtype ResumableC err m a = ResumableC {
- runResumableC :: m (Either (SomeError err) a)
}
runResumableWith :: (Carrier sig m, Monad m) => (forall x. err x -> m x) -> Eff (ResumableWithC err m) a -> m a
newtype ResumableWithC err m a = ResumableWithC ((forall x. err x -> m x) -> m a)

Documentation

data Resumable err (m :: * -> *) k Source #

Errors which can be resumed with values of some existentially-quantified type.

Constructors

Resumable (err a) (a -> k)

Instances

Effect (Resumable err) Source #
Instance details Defined in Control.Effect.Resumable Methods handle :: Functor f => f () -> (forall x. f (m x) -> n (f x)) -> Resumable err m (m a) -> Resumable err n (n (f a)) Source #
HFunctor (Resumable err) Source #
Instance details Defined in Control.Effect.Resumable Methods fmap' :: (a -> b) -> Resumable err m a -> Resumable err m b Source # hmap :: (forall x. m x -> n x) -> Resumable err m a -> Resumable err n a Source #
Functor (Resumable err m) Source #
Instance details Defined in Control.Effect.Resumable Methods fmap :: (a -> b) -> Resumable err m a -> Resumable err m b # (<$) :: a -> Resumable err m b -> Resumable err m a #
(Carrier sig m, Monad m) => Carrier (Resumable err :+: sig) (ResumableWithC err m) Source #
Instance details Defined in Control.Effect.Resumable Methods ret :: a -> ResumableWithC err m a Source # eff :: (Resumable err :+: sig) (ResumableWithC err m) (ResumableWithC err m a) -> ResumableWithC err m a Source #
(Carrier sig m, Effect sig) => Carrier (Resumable err :+: sig) (ResumableC err m) Source #
Instance details Defined in Control.Effect.Resumable Methods ret :: a -> ResumableC err m a Source # eff :: (Resumable err :+: sig) (ResumableC err m) (ResumableC err m a) -> ResumableC err m a Source #

throwResumable :: (Member (Resumable err) sig, Carrier sig m) => err a -> m a Source #

Throw an error which can be resumed with a value of its result type.

run (runResumable (throwResumable (Identity a))) == Left (SomeError (Identity a))

data SomeError (err :: * -> *) Source #

An error at some existentially-quantified type index.

Constructors

SomeError (err a)

Instances

Eq1 err => Eq (SomeError err) Source #	Equality for `SomeError` is determined by an `Eq1` instance for the error type. Note that since we can’t tell whether the type indices are equal, let alone what `Eq` instance to use for them, the comparator passed to `liftEq` always returns `True`. Thus, `SomeError` is best used with type-indexed GADTs for the error type. SomeError (Identity a) == SomeError (Identity b) (SomeError (Const a) == SomeError (Const b)) == (a == b)
Instance details Defined in Control.Effect.Resumable Methods (==) :: SomeError err -> SomeError err -> Bool # (/=) :: SomeError err -> SomeError err -> Bool #
Ord1 err => Ord (SomeError err) Source #	Ordering for `SomeError` is determined by an `Ord1` instance for the error type. Note that since we can’t tell whether the type indices are equal, let alone what `Ord` instance to use for them, the comparator passed to `liftCompare` always returns `EQ`. Thus, `SomeError` is best used with type-indexed GADTs for the error type. (SomeError (Identity a) `compare` SomeError (Identity b)) == EQ (SomeError (Const a) `compare` SomeError (Const b)) == (a `compare` b)
Instance details Defined in Control.Effect.Resumable Methods compare :: SomeError err -> SomeError err -> Ordering # (<) :: SomeError err -> SomeError err -> Bool # (<=) :: SomeError err -> SomeError err -> Bool # (>) :: SomeError err -> SomeError err -> Bool # (>=) :: SomeError err -> SomeError err -> Bool # max :: SomeError err -> SomeError err -> SomeError err # min :: SomeError err -> SomeError err -> SomeError err #
Show1 err => Show (SomeError err) Source #	Showing for `SomeError` is determined by a `Show1` instance for the error type. Note that since we can’t tell what `Show` instance to use for the type index, the functions passed to `liftShowsPrec` always return the empty `ShowS`. Thus, `SomeError` is best used with type-indexed GADTs for the error type. show (SomeError (Identity a)) == "SomeError (Identity )" show (SomeError (Const a)) == ("SomeError (Const " ++ showsPrec 11 a ")")
Instance details Defined in Control.Effect.Resumable Methods showsPrec :: Int -> SomeError err -> ShowS # show :: SomeError err -> String # showList :: [SomeError err] -> ShowS #
NFData1 err => NFData (SomeError err) Source #	Evaluation of `SomeError` to normal forms is determined by a `NFData1` instance for the error type. pure (rnf (SomeError (Identity (error "error"))) :: SomeError Identity) `shouldThrow` errorCall "error"
Instance details Defined in Control.Effect.Resumable Methods rnf :: SomeError err -> () #

runResumable :: (Carrier sig m, Effect sig) => Eff (ResumableC err m) a -> m (Either (SomeError err) a) Source #

Run a Resumable effect, returning uncaught errors in Left and successful computations’ values in Right.

run (runResumable (pure a)) == Right @(SomeError Identity) @Int a

newtype ResumableC err m a Source #

Constructors

ResumableC
Fields runResumableC :: m (Either (SomeError err) a)

Instances

(Carrier sig m, Effect sig) => Carrier (Resumable err :+: sig) (ResumableC err m) Source #
Instance details Defined in Control.Effect.Resumable Methods ret :: a -> ResumableC err m a Source # eff :: (Resumable err :+: sig) (ResumableC err m) (ResumableC err m a) -> ResumableC err m a Source #

runResumableWith :: (Carrier sig m, Monad m) => (forall x. err x -> m x) -> Eff (ResumableWithC err m) a -> m a Source #

Run a Resumable effect, resuming uncaught errors with a given handler.

Note that this may be less efficient than defining a specialized carrier type and instance specifying the handler’s behaviour directly. Performance-critical code may wish to do that to maximize the opportunities for fusion and inlining.

>>> data Err a where Err :: Int -> Err Int

run (runResumableWith (\ (Err b) -> pure (1 + b)) (pure a)) == a

run (runResumableWith (\ (Err b) -> pure (1 + b)) (throwResumable (Err a))) == 1 + a

newtype ResumableWithC err m a Source #

Constructors

ResumableWithC ((forall x. err x -> m x) -> m a)

Instances

(Carrier sig m, Monad m) => Carrier (Resumable err :+: sig) (ResumableWithC err m) Source #
Instance details Defined in Control.Effect.Resumable Methods ret :: a -> ResumableWithC err m a Source # eff :: (Resumable err :+: sig) (ResumableWithC err m) (ResumableWithC err m a) -> ResumableWithC err m a Source #