Control.Effect.Resumable

Documentation

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

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

Constructors

Resumable (err a) (a -> k)

Instances

Effect (Resumable err)

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

HFunctor (Resumable err)

Defined in Control.Effect.Resumable

Methods

fmap' :: (a -> b) -> Resumable err m a -> Resumable err m b

hmap :: (forall x. m x -> n x) -> Resumable err m a -> Resumable err n a

Functor (Resumable err m)

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)

Defined in Control.Effect.Resumable

Methods

ret :: a -> ResumableWithC err m a

eff :: (Resumable err :+: sig) (ResumableWithC err m) (ResumableWithC err m a) -> ResumableWithC err m a

(Carrier sig m, Effect sig) => Carrier (Resumable err :+: sig) (ResumableC err m)

Defined in Control.Effect.Resumable

Methods

ret :: a -> ResumableC err m a

eff :: (Resumable err :+: sig) (ResumableC err m) (ResumableC err m a) -> ResumableC err m a

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

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

An error at some existentially-quantified type index.

Constructors

SomeError (err a)

Instances

Eq1 err => Eq (SomeError err)

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)

Defined in Control.Effect.Resumable

Methods

(==) :: SomeError err -> SomeError err -> Bool

(/=) :: SomeError err -> SomeError err -> Bool

Ord1 err => Ord (SomeError err)

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)

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)

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

Defined in Control.Effect.Resumable

Methods

showsPrec :: Int -> SomeError err -> ShowS

show :: SomeError err -> String

showList :: [SomeError err] -> ShowS

NFData1 err => NFData (SomeError err)

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"

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)

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

Constructors

ResumableC

Fields

• runResumableC :: m (Either (SomeError err) a)

Instances

(Carrier sig m, Effect sig) => Carrier (Resumable err :+: sig) (ResumableC err m)

Defined in Control.Effect.Resumable

Methods

ret :: a -> ResumableC err m a

eff :: (Resumable err :+: sig) (ResumableC err m) (ResumableC err m a) -> ResumableC err m a

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

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

Constructors

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

Instances

(Carrier sig m, Monad m) => Carrier (Resumable err :+: sig) (ResumableWithC err m)

Defined in Control.Effect.Resumable

Methods

ret :: a -> ResumableWithC err m a

eff :: (Resumable err :+: sig) (ResumableWithC err m) (ResumableWithC err m a) -> ResumableWithC err m a