polysemy-resume 0.9.0.0 → 0.9.0.1

raw patch · 1 files changed

+6/−6 lines, 1 filesdep ~basedep ~tastyPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: base, tasty

API changes (from Hackage documentation)

- Polysemy.Resume: [Stop] :: e -> Stop e m a

- Polysemy.Resume: data Stop e :: Effect

- Polysemy.Resume: stop :: forall e_a4EX r_a5Vr a_a4EZ. Member (Stop e_a4EX) r_a5Vr => e_a4EX -> Sem r_a5Vr a_a4EZ

- Polysemy.Resume: type eff !! err = Resumable err eff

- Polysemy.Resume.Effect.Resumable: type eff !! err = Resumable err eff

- Polysemy.Resume.Interpreter.Stop: [$sel:unStopExc:StopExc] :: StopExc err -> err

+ Polysemy.Resume: type (eff :: Type -> Type -> Type -> Type) !! err = Resumable err eff

+ Polysemy.Resume.Effect.Resumable: type (eff :: Type -> Type -> Type -> Type) !! err = Resumable err eff

+ Polysemy.Resume.Interpreter.Stop: [unStopExc] :: StopExc err -> err

- Polysemy.Resume: (!!) :: forall err eff r a. Member (Resumable err eff) r => Sem (eff : r) a -> (err -> Sem r a) -> Sem r a

+ Polysemy.Resume: (!!) :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem (eff ': r) a -> (err -> Sem r a) -> Sem r a

- Polysemy.Resume: (!>) :: forall err eff r a. Member (Resumable err eff) r => Sem (eff : r) a -> a -> Sem r a

+ Polysemy.Resume: (!>) :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem (eff ': r) a -> a -> Sem r a

- Polysemy.Resume: (!>>) :: forall err eff r a. Member (Resumable err eff) r => Sem (eff : r) a -> Sem r a -> Sem r a

+ Polysemy.Resume: (!>>) :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem (eff ': r) a -> Sem r a -> Sem r a

- Polysemy.Resume: (<!) :: forall err eff r a. Member (Resumable err eff) r => a -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume: (<!) :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => a -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume: (<<!) :: forall err eff r a. Member (Resumable err eff) r => Sem r a -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume: (<<!) :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem r a -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume: catchResumable :: forall (err :: Type) (eff :: Effect) handled r. Members [eff, Error err] r => (err -> Maybe handled) -> InterpreterFor (Resumable handled eff) r

+ Polysemy.Resume: catchResumable :: forall err (eff :: Effect) handled (r :: EffectRow). Members '[eff, Error err :: (Type -> Type) -> Type -> Type] r => (err -> Maybe handled) -> InterpreterFor (Resumable handled eff) r

- Polysemy.Resume: data Resumable err eff :: Effect

+ Polysemy.Resume: data Resumable err (eff :: Type -> Type -> Type -> Type) (a :: Type -> Type) b

- Polysemy.Resume: interceptResumable :: forall (err :: Type) (eff :: Effect) (r :: EffectRow) (a :: Type). Member (Resumable err eff) r => FirstOrder eff "interceptResumable" => (forall x r0. eff (Sem r0) x -> Sem (Stop err : r) x) -> Sem r a -> Sem r a

+ Polysemy.Resume: interceptResumable :: forall err eff (r :: EffectRow) a. (Member (Resumable err eff) r, FirstOrder eff "interceptResumable") => (forall x (r0 :: EffectRow). () => eff (Sem r0) x -> Sem (Stop err ': r) x) -> Sem r a -> Sem r a

- Polysemy.Resume: interceptResumableH :: forall (err :: Type) (eff :: Effect) (r :: EffectRow) (a :: Type). Member (Resumable err eff) r => (forall x r0. eff (Sem r0) x -> Tactical (Resumable err eff) (Sem r0) (Stop err : r) x) -> Sem r a -> Sem r a

+ Polysemy.Resume: interceptResumableH :: forall err eff (r :: EffectRow) a. Member (Resumable err eff) r => (forall x (r0 :: EffectRow). () => eff (Sem r0) x -> Tactical (Resumable err eff) (Sem r0) (Stop err ': r) x) -> Sem r a -> Sem r a

- Polysemy.Resume: interceptResumableUsing :: forall (err :: Type) (eff :: Effect) (r :: EffectRow) (a :: Type). FirstOrder eff "interceptResumableUsing" => ElemOf (Resumable err eff) r -> (forall x r0. eff (Sem r0) x -> Sem (Stop err : r) x) -> Sem r a -> Sem r a

+ Polysemy.Resume: interceptResumableUsing :: forall err eff (r :: EffectRow) a. FirstOrder eff "interceptResumableUsing" => ElemOf (Resumable err eff) r -> (forall x (r0 :: EffectRow). () => eff (Sem r0) x -> Sem (Stop err ': r) x) -> Sem r a -> Sem r a

- Polysemy.Resume: interceptResumableUsingH :: forall (err :: Type) (eff :: Effect) (r :: EffectRow) (a :: Type). ElemOf (Resumable err eff) r -> (forall x r0. eff (Sem r0) x -> Tactical (Resumable err eff) (Sem r0) (Stop err : r) x) -> Sem r a -> Sem r a

+ Polysemy.Resume: interceptResumableUsingH :: forall err eff (r :: EffectRow) a. ElemOf (Resumable err eff) r -> (forall x (r0 :: EffectRow). () => eff (Sem r0) x -> Tactical (Resumable err eff) (Sem r0) (Stop err ': r) x) -> Sem r a -> Sem r a

- Polysemy.Resume: interpretResumable :: forall (err :: Type) (eff :: Effect) r. FirstOrder eff "interpretResumable" => (forall x r0. eff (Sem r0) x -> Sem (Stop err : r) x) -> InterpreterFor (Resumable err eff) r

+ Polysemy.Resume: interpretResumable :: forall err eff (r :: [Effect]). FirstOrder eff "interpretResumable" => (forall x (r0 :: EffectRow). () => eff (Sem r0) x -> Sem (Stop err ': r) x) -> InterpreterFor (Resumable err eff) r

- Polysemy.Resume: interpretResumableH :: forall (err :: Type) (eff :: Effect) (r :: EffectRow). (forall x r0. eff (Sem r0) x -> Tactical (Resumable err eff) (Sem r0) (Stop err : r) x) -> InterpreterFor (Resumable err eff) r

+ Polysemy.Resume: interpretResumableH :: forall err eff (r :: EffectRow). (forall x (r0 :: EffectRow). () => eff (Sem r0) x -> Tactical (Resumable err eff) (Sem r0) (Stop err ': r) x) -> InterpreterFor (Resumable err eff) r

- Polysemy.Resume: interpretResumableScoped :: forall param resource effect err r. (forall q x. param -> (resource -> Sem (Opaque q : r) x) -> Sem (Opaque q : r) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (Stop err : (Opaque q : r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

+ Polysemy.Resume: interpretResumableScoped :: forall param resource effect err (r :: [Effect]). (forall (q :: Effect) x. () => param -> (resource -> Sem (Opaque q ': r) x) -> Sem (Opaque q ': r) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop err ': (Opaque q ': r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

- Polysemy.Resume: interpretResumableScopedH :: forall param resource effect err r. (forall q x. param -> (resource -> Sem (Opaque q : r) x) -> Sem (Opaque q : r) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Tactical (effect !! err) (Sem r0) (Stop err : (Opaque q : r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

+ Polysemy.Resume: interpretResumableScopedH :: forall param resource effect err (r :: [Effect]). (forall (q :: Effect) x. () => param -> (resource -> Sem (Opaque q ': r) x) -> Sem (Opaque q ': r) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Tactical (effect !! err) (Sem r0) (Stop err ': (Opaque q ': r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

- Polysemy.Resume: interpretResumableScopedWith :: forall extra param resource effect err r. KnownList extra => (forall q x. param -> (resource -> Sem (extra ++ (Opaque q : r)) x) -> Sem (Opaque q : r) x) -> (forall r0 x. resource -> effect (Sem r0) x -> Sem (Stop err : (extra ++ r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

+ Polysemy.Resume: interpretResumableScopedWith :: forall (extra :: [(Type -> Type) -> Type -> Type]) param resource effect err (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> (resource -> Sem (extra ++ (Opaque q ': r)) x) -> Sem (Opaque q ': r) x) -> (forall (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop err ': (extra ++ r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

- Polysemy.Resume: interpretResumableScopedWithH :: forall extra param resource effect err r. KnownList extra => (forall q x. param -> (resource -> Sem (extra ++ (Opaque q : r)) x) -> Sem (Opaque q : r) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Tactical (effect !! err) (Sem r0) (Stop err : (extra ++ (Opaque q : r))) x) -> InterpreterFor (Scoped param (effect !! err)) r

+ Polysemy.Resume: interpretResumableScopedWithH :: forall (extra :: [(Type -> Type) -> Type -> Type]) param resource effect err (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> (resource -> Sem (extra ++ (Opaque q ': r)) x) -> Sem (Opaque q ': r) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Tactical (effect !! err) (Sem r0) (Stop err ': (extra ++ (Opaque q ': r))) x) -> InterpreterFor (Scoped param (effect !! err)) r

- Polysemy.Resume: interpretResumableScopedWith_ :: forall extra param effect err r. KnownList extra => (forall q x. param -> Sem (extra ++ (Opaque q : r)) x -> Sem (Opaque q : r) x) -> (forall r0 x. effect (Sem r0) x -> Sem (Stop err : (extra ++ r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

+ Polysemy.Resume: interpretResumableScopedWith_ :: forall (extra :: [(Type -> Type) -> Type -> Type]) param effect err (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> Sem (extra ++ (Opaque q ': r)) x -> Sem (Opaque q ': r) x) -> (forall (r0 :: EffectRow) x. () => effect (Sem r0) x -> Sem (Stop err ': (extra ++ r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

- Polysemy.Resume: interpretResumableScoped_ :: forall param resource effect err r. (param -> Sem r resource) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (Stop err : (Opaque q : r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

+ Polysemy.Resume: interpretResumableScoped_ :: forall param resource effect err (r :: EffectRow). (param -> Sem r resource) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop err ': (Opaque q ': r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

- Polysemy.Resume: interpretScopedR :: forall param resource effect eo ei r. (forall q x. param -> (resource -> Sem (Stop eo : (Opaque q : r)) x) -> Sem (Stop eo : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (Stop ei : (Stop eo : (Opaque q : r))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

+ Polysemy.Resume: interpretScopedR :: forall param resource effect eo ei (r :: [Effect]). (forall (q :: Effect) x. () => param -> (resource -> Sem (Stop eo ': (Opaque q ': r)) x) -> Sem (Stop eo ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop ei ': (Stop eo ': (Opaque q ': r))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

- Polysemy.Resume: interpretScopedRH :: forall param resource effect eo ei r. (forall q x. param -> (resource -> Sem (Stop eo : (Opaque q : r)) x) -> Sem (Stop eo : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Tactical (effect !! ei) (Sem r0) (Stop ei : (Stop eo : (Opaque q : r))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

+ Polysemy.Resume: interpretScopedRH :: forall param resource effect eo ei (r :: [Effect]). (forall (q :: Effect) x. () => param -> (resource -> Sem (Stop eo ': (Opaque q ': r)) x) -> Sem (Stop eo ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Tactical (effect !! ei) (Sem r0) (Stop ei ': (Stop eo ': (Opaque q ': r))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

- Polysemy.Resume: interpretScopedRWith :: forall extra param resource effect eo ei r. KnownList extra => (forall q x. param -> (resource -> Sem (extra ++ (Stop eo : (Opaque q : r))) x) -> Sem (Stop eo : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (Stop ei : (extra ++ (Stop eo : (Opaque q : r)))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

+ Polysemy.Resume: interpretScopedRWith :: forall (extra :: [(Type -> Type) -> Type -> Type]) param resource effect eo ei (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> (resource -> Sem (extra ++ (Stop eo ': (Opaque q ': r))) x) -> Sem (Stop eo ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop ei ': (extra ++ (Stop eo ': (Opaque q ': r)))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

- Polysemy.Resume: interpretScopedRWithH :: forall extra param resource effect eo ei r. KnownList extra => (forall q x. param -> (resource -> Sem (extra ++ (Stop eo : (Opaque q : r))) x) -> Sem (Stop eo : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Tactical (effect !! ei) (Sem r0) (Stop ei : (extra ++ (Stop eo : (Opaque q : r)))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

+ Polysemy.Resume: interpretScopedRWithH :: forall (extra :: [(Type -> Type) -> Type -> Type]) param resource effect eo ei (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> (resource -> Sem (extra ++ (Stop eo ': (Opaque q ': r))) x) -> Sem (Stop eo ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Tactical (effect !! ei) (Sem r0) (Stop ei ': (extra ++ (Stop eo ': (Opaque q ': r)))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

- Polysemy.Resume: interpretScopedRWith_ :: forall extra param effect eo ei r. KnownList extra => (forall q x. param -> Sem (extra ++ (Stop eo : (Opaque q : r))) x -> Sem (Stop eo : (Opaque q : r)) x) -> (forall q r0 x. effect (Sem r0) x -> Sem (Stop ei : (extra ++ (Stop eo : (Opaque q : r)))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

+ Polysemy.Resume: interpretScopedRWith_ :: forall (extra :: [(Type -> Type) -> Type -> Type]) param effect eo ei (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> Sem (extra ++ (Stop eo ': (Opaque q ': r))) x -> Sem (Stop eo ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => effect (Sem r0) x -> Sem (Stop ei ': (extra ++ (Stop eo ': (Opaque q ': r)))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

- Polysemy.Resume: interpretScopedR_ :: forall param resource effect eo ei r. (param -> Sem (Stop eo : r) resource) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (Stop ei : (Stop eo : (Opaque q : r))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

+ Polysemy.Resume: interpretScopedR_ :: forall param resource effect eo ei (r :: [(Type -> Type) -> Type -> Type]). (param -> Sem (Stop eo ': r) resource) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop ei ': (Stop eo ': (Opaque q ': r))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

- Polysemy.Resume: interpretScopedResumable :: forall param resource effect err r. (forall q x. param -> (resource -> Sem (Stop err : (Opaque q : r)) x) -> Sem (Stop err : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (Stop err : (Opaque q : r)) x) -> InterpreterFor (Scoped param effect !! err) r

+ Polysemy.Resume: interpretScopedResumable :: forall param resource effect err (r :: [Effect]). (forall (q :: Effect) x. () => param -> (resource -> Sem (Stop err ': (Opaque q ': r)) x) -> Sem (Stop err ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop err ': (Opaque q ': r)) x) -> InterpreterFor (Scoped param effect !! err) r

- Polysemy.Resume: interpretScopedResumableH :: forall param resource effect err r. (forall q x. param -> (resource -> Sem (Stop err : (Opaque q : r)) x) -> Sem (Stop err : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Tactical effect (Sem r0) (Stop err : (Opaque q : r)) x) -> InterpreterFor (Scoped param effect !! err) r

+ Polysemy.Resume: interpretScopedResumableH :: forall param resource effect err (r :: [Effect]). (forall (q :: Effect) x. () => param -> (resource -> Sem (Stop err ': (Opaque q ': r)) x) -> Sem (Stop err ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Tactical effect (Sem r0) (Stop err ': (Opaque q ': r)) x) -> InterpreterFor (Scoped param effect !! err) r

- Polysemy.Resume: interpretScopedResumableWith :: forall extra param resource effect err r. KnownList extra => (forall q x. param -> (resource -> Sem (extra ++ (Stop err : (Opaque q : r))) x) -> Sem (Stop err : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (extra ++ (Stop err : (Opaque q : r))) x) -> InterpreterFor (Scoped param effect !! err) r

+ Polysemy.Resume: interpretScopedResumableWith :: forall (extra :: [(Type -> Type) -> Type -> Type]) param resource effect err (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> (resource -> Sem (extra ++ (Stop err ': (Opaque q ': r))) x) -> Sem (Stop err ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (extra ++ (Stop err ': (Opaque q ': r))) x) -> InterpreterFor (Scoped param effect !! err) r

- Polysemy.Resume: interpretScopedResumableWithH :: forall extra param resource effect err r. KnownList extra => (forall q x. param -> (resource -> Sem (extra ++ (Stop err : (Opaque q : r))) x) -> Sem (Stop err : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Tactical effect (Sem r0) (extra ++ ([Stop err, Opaque q] ++ r)) x) -> InterpreterFor (Scoped param effect !! err) r

+ Polysemy.Resume: interpretScopedResumableWithH :: forall (extra :: [(Type -> Type) -> Type -> Type]) param resource effect err (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> (resource -> Sem (extra ++ (Stop err ': (Opaque q ': r))) x) -> Sem (Stop err ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Tactical effect (Sem r0) (extra ++ ('[Stop err, Opaque q] ++ r)) x) -> InterpreterFor (Scoped param effect !! err) r

- Polysemy.Resume: interpretScopedResumableWith_ :: forall extra param effect err r. KnownList extra => (forall q x. param -> Sem (extra ++ (Stop err : (Opaque q : r))) x -> Sem (Stop err : (Opaque q : r)) x) -> (forall q r0 x. effect (Sem r0) x -> Sem (extra ++ (Stop err : (Opaque q : r))) x) -> InterpreterFor (Scoped param effect !! err) r

+ Polysemy.Resume: interpretScopedResumableWith_ :: forall (extra :: [(Type -> Type) -> Type -> Type]) param effect err (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> Sem (extra ++ (Stop err ': (Opaque q ': r))) x -> Sem (Stop err ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => effect (Sem r0) x -> Sem (extra ++ (Stop err ': (Opaque q ': r))) x) -> InterpreterFor (Scoped param effect !! err) r

- Polysemy.Resume: interpretScopedResumable_ :: forall param resource effect err r. (forall q. param -> Sem (Stop err : (Opaque q : r)) resource) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (Stop err : (Opaque q : r)) x) -> InterpreterFor (Scoped param effect !! err) r

+ Polysemy.Resume: interpretScopedResumable_ :: forall param resource effect err (r :: [Effect]). (forall (q :: Effect). () => param -> Sem (Stop err ': (Opaque q ': r)) resource) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop err ': (Opaque q ': r)) x) -> InterpreterFor (Scoped param effect !! err) r

- Polysemy.Resume: mapStop :: forall err e' r a. Member (Stop e') r => (err -> e') -> Sem (Stop err : r) a -> Sem r a

+ Polysemy.Resume: mapStop :: forall err e' (r :: EffectRow) a. Member (Stop e') r => (err -> e') -> Sem (Stop err ': r) a -> Sem r a

- Polysemy.Resume: raiseResumable :: forall (err :: Type) (eff :: Effect) (r :: EffectRow). InterpreterTrans (Resumable err eff) eff r

+ Polysemy.Resume: raiseResumable :: forall err (eff :: Effect) (r :: EffectRow) a b. (Sem (eff ': r) a -> Sem r b) -> Sem (Resumable err eff ': r) a -> Sem r b

- Polysemy.Resume: replaceStop :: forall err e' r a. Member (Stop e') r => e' -> Sem (Stop err : r) a -> Sem r a

+ Polysemy.Resume: replaceStop :: forall err e' (r :: EffectRow) a. Member (Stop e') r => e' -> Sem (Stop err ': r) a -> Sem r a

- Polysemy.Resume: restop :: forall err eff r. Members [Resumable err eff, Stop err] r => InterpreterFor eff r

+ Polysemy.Resume: restop :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow). Members '[Resumable err eff, Stop err] r => InterpreterFor eff r

- Polysemy.Resume: resumable :: forall (err :: Type) (eff :: Effect) (r :: EffectRow). InterpreterFor eff (Stop err : r) -> InterpreterFor (Resumable err eff) r

+ Polysemy.Resume: resumable :: forall err (eff :: Effect) (r :: EffectRow). InterpreterFor eff (Stop err ': r) -> InterpreterFor (Resumable err eff) r

- Polysemy.Resume: resumableError :: forall (err :: Type) (eff :: Effect) r. InterpreterFor eff (Error err : (Stop err : r)) -> InterpreterFor (Resumable err eff) r

+ Polysemy.Resume: resumableError :: forall err (eff :: Effect) (r :: [(Type -> Type) -> Type -> Type]). InterpreterFor eff ((Error err :: (Type -> Type) -> Type -> Type) ': (Stop err ': r)) -> InterpreterFor (Resumable err eff) r

- Polysemy.Resume: resumableFor :: forall (err :: Type) (eff :: Effect) handled r. Member (Error err) r => (err -> Maybe handled) -> InterpreterFor eff (Stop err : r) -> InterpreterFor (Resumable handled eff) r

+ Polysemy.Resume: resumableFor :: forall err (eff :: Effect) handled (r :: EffectRow). Member (Error err :: (Type -> Type) -> Type -> Type) r => (err -> Maybe handled) -> InterpreterFor eff (Stop err ': r) -> InterpreterFor (Resumable handled eff) r

- Polysemy.Resume: resumableIO :: forall (err :: Type) (eff :: Effect) (r :: EffectRow). Exception (StopExc err) => Member (Final IO) r => InterpreterFor eff (Stop err : r) -> InterpreterFor (Resumable err eff) r

+ Polysemy.Resume: resumableIO :: forall err (eff :: Effect) (r :: EffectRow). (Exception (StopExc err), Member (Final IO) r) => InterpreterFor eff (Stop err ': r) -> InterpreterFor (Resumable err eff) r

- Polysemy.Resume: resumableOr :: forall (err :: Type) (eff :: Effect) unhandled handled r. Member (Error unhandled) r => (err -> Either unhandled handled) -> InterpreterFor eff (Stop err : r) -> InterpreterFor (Resumable handled eff) r

+ Polysemy.Resume: resumableOr :: forall err (eff :: Effect) unhandled handled (r :: EffectRow). Member (Error unhandled :: (Type -> Type) -> Type -> Type) r => (err -> Either unhandled handled) -> InterpreterFor eff (Stop err ': r) -> InterpreterFor (Resumable handled eff) r

- Polysemy.Resume: resume :: forall err eff r a. Member (Resumable err eff) r => Sem (eff : r) a -> (err -> Sem r a) -> Sem r a

+ Polysemy.Resume: resume :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem (eff ': r) a -> (err -> Sem r a) -> Sem r a

- Polysemy.Resume: resumeAs :: forall err eff r a. Member (Resumable err eff) r => a -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume: resumeAs :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => a -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume: resumeEither :: forall err eff r a. Member (Resumable err eff) r => Sem (eff : r) a -> Sem r (Either err a)

+ Polysemy.Resume: resumeEither :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem (eff ': r) a -> Sem r (Either err a)

- Polysemy.Resume: resumeError :: forall err eff r a. Members [Resumable err eff, Error err] r => Sem (eff : r) a -> Sem r a

+ Polysemy.Resume: resumeError :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Members '[Resumable err eff, Error err :: (Type -> Type) -> Type -> Type] r => Sem (eff ': r) a -> Sem r a

- Polysemy.Resume: resumeFail :: forall err eff r. Show err => Members [Fail, Resumable err eff] r => InterpreterFor eff r

+ Polysemy.Resume: resumeFail :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow). (Show err, Members '[Fail :: (Type -> Type) -> Type -> Type, Resumable err eff] r) => InterpreterFor eff r

- Polysemy.Resume: resumeFailWith :: forall err eff r. Members [Fail, Resumable err eff] r => (err -> Text) -> InterpreterFor eff r

+ Polysemy.Resume: resumeFailWith :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow). Members '[Fail :: (Type -> Type) -> Type -> Type, Resumable err eff] r => (err -> Text) -> InterpreterFor eff r

- Polysemy.Resume: resumeHoist :: forall err eff err' r a. Members [Resumable err eff, Stop err'] r => (err -> err') -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume: resumeHoist :: forall err (eff :: (Type -> Type) -> Type -> Type) err' (r :: EffectRow) a. Members '[Resumable err eff, Stop err'] r => (err -> err') -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume: resumeHoistAs :: forall err eff err' r. Members [Resumable err eff, Stop err'] r => err' -> InterpreterFor eff r

+ Polysemy.Resume: resumeHoistAs :: forall err (eff :: (Type -> Type) -> Type -> Type) err' (r :: EffectRow). Members '[Resumable err eff, Stop err'] r => err' -> InterpreterFor eff r

- Polysemy.Resume: resumeHoistError :: forall err eff err' r a. Members [Resumable err eff, Error err'] r => (err -> err') -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume: resumeHoistError :: forall err (eff :: (Type -> Type) -> Type -> Type) err' (r :: EffectRow) a. Members '[Resumable err eff, Error err' :: (Type -> Type) -> Type -> Type] r => (err -> err') -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume: resumeHoistErrorAs :: forall err eff err' r a. Members [Resumable err eff, Error err'] r => err' -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume: resumeHoistErrorAs :: forall err (eff :: (Type -> Type) -> Type -> Type) err' (r :: EffectRow) a. Members '[Resumable err eff, Error err' :: (Type -> Type) -> Type -> Type] r => err' -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume: resumeMaybe :: forall err eff r a. Member (Resumable err eff) r => Sem (eff : r) a -> Sem r (Maybe a)

+ Polysemy.Resume: resumeMaybe :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem (eff ': r) a -> Sem r (Maybe a)

- Polysemy.Resume: resumeOr :: forall err eff r a b. Member (Resumable err eff) r => Sem (eff : r) a -> (a -> Sem r b) -> (err -> Sem r b) -> Sem r b

+ Polysemy.Resume: resumeOr :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a b. Member (Resumable err eff) r => Sem (eff ': r) a -> (a -> Sem r b) -> (err -> Sem r b) -> Sem r b

- Polysemy.Resume: resumeWith :: forall err eff r a. Member (Resumable err eff) r => Sem (eff : r) a -> Sem r a -> Sem r a

+ Polysemy.Resume: resumeWith :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem (eff ': r) a -> Sem r a -> Sem r a

- Polysemy.Resume: resume_ :: forall err eff r. Member (Resumable err eff) r => Sem (eff : r) () -> Sem r ()

+ Polysemy.Resume: resume_ :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow). Member (Resumable err eff) r => Sem (eff ': r) () -> Sem r ()

- Polysemy.Resume: resuming :: forall err eff r a. Member (Resumable err eff) r => (err -> Sem r a) -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume: resuming :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => (err -> Sem r a) -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume: resumingOr :: forall err eff r a b. Member (Resumable err eff) r => (err -> Sem r b) -> Sem (eff : r) a -> (a -> Sem r b) -> Sem r b

+ Polysemy.Resume: resumingOr :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a b. Member (Resumable err eff) r => (err -> Sem r b) -> Sem (eff ': r) a -> (a -> Sem r b) -> Sem r b

- Polysemy.Resume: resumingWith :: forall err eff r a. Member (Resumable err eff) r => Sem r a -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume: resumingWith :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem r a -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume: runAsResumable :: forall (err :: Type) (eff :: Effect) r. Members [Resumable err eff, Stop err] r => InterpreterFor eff r

+ Polysemy.Resume: runAsResumable :: forall err (eff :: Effect) (r :: EffectRow). Members '[Resumable err eff, Stop err] r => InterpreterFor eff r

- Polysemy.Resume: runStop :: Sem (Stop err : r) a -> Sem r (Either err a)

+ Polysemy.Resume: runStop :: forall err (r :: [(Type -> Type) -> Type -> Type]) a. Sem (Stop err ': r) a -> Sem r (Either err a)

- Polysemy.Resume: showStop :: forall err r a. Show err => Member (Stop Text) r => Sem (Stop err : r) a -> Sem r a

+ Polysemy.Resume: showStop :: forall err (r :: EffectRow) a. (Show err, Member (Stop Text) r) => Sem (Stop err ': r) a -> Sem r a

- Polysemy.Resume: stopEither :: forall err r a. Member (Stop err) r => Either err a -> Sem r a

+ Polysemy.Resume: stopEither :: forall err (r :: EffectRow) a. Member (Stop err) r => Either err a -> Sem r a

- Polysemy.Resume: stopEitherAs :: forall err err' r a. Member (Stop err') r => err' -> Either err a -> Sem r a

+ Polysemy.Resume: stopEitherAs :: forall err err' (r :: EffectRow) a. Member (Stop err') r => err' -> Either err a -> Sem r a

- Polysemy.Resume: stopEitherWith :: forall err err' r a. Member (Stop err') r => (err -> err') -> Either err a -> Sem r a

+ Polysemy.Resume: stopEitherWith :: forall err err' (r :: EffectRow) a. Member (Stop err') r => (err -> err') -> Either err a -> Sem r a

- Polysemy.Resume: stopNote :: forall err r a. Member (Stop err) r => err -> Maybe a -> Sem r a

+ Polysemy.Resume: stopNote :: forall err (r :: EffectRow) a. Member (Stop err) r => err -> Maybe a -> Sem r a

- Polysemy.Resume: stopOnError :: forall err r a. Member (Stop err) r => Sem (Error err : r) a -> Sem r a

+ Polysemy.Resume: stopOnError :: forall err (r :: EffectRow) a. Member (Stop err) r => Sem ((Error err :: (Type -> Type) -> Type -> Type) ': r) a -> Sem r a

- Polysemy.Resume: stopOnErrorWith :: forall err err' r a. Member (Stop err') r => (err -> err') -> Sem (Error err : r) a -> Sem r a

+ Polysemy.Resume: stopOnErrorWith :: forall err err' (r :: EffectRow) a. Member (Stop err') r => (err -> err') -> Sem ((Error err :: (Type -> Type) -> Type -> Type) ': r) a -> Sem r a

- Polysemy.Resume: stopToError :: forall err r a. Member (Error err) r => Sem (Stop err : r) a -> Sem r a

+ Polysemy.Resume: stopToError :: forall err (r :: EffectRow) a. Member (Error err :: (Type -> Type) -> Type -> Type) r => Sem (Stop err ': r) a -> Sem r a

- Polysemy.Resume: stopToErrorIO :: forall err r a. Exception (StopExc err) => Members [Error err, Final IO] r => Sem (Stop err : r) a -> Sem r a

+ Polysemy.Resume: stopToErrorIO :: forall err (r :: EffectRow) a. (Exception (StopExc err), Members '[Error err :: (Type -> Type) -> Type -> Type, Final IO] r) => Sem (Stop err ': r) a -> Sem r a

- Polysemy.Resume: stopToErrorWith :: forall err err' r a. Member (Error err') r => (err -> err') -> Sem (Stop err : r) a -> Sem r a

+ Polysemy.Resume: stopToErrorWith :: forall err err' (r :: EffectRow) a. Member (Error err' :: (Type -> Type) -> Type -> Type) r => (err -> err') -> Sem (Stop err ': r) a -> Sem r a

- Polysemy.Resume: stopToFail :: forall err r. Show err => Member Fail r => InterpreterFor (Stop err) r

+ Polysemy.Resume: stopToFail :: forall err (r :: EffectRow). (Show err, Member (Fail :: (Type -> Type) -> Type -> Type) r) => InterpreterFor (Stop err) r

- Polysemy.Resume: stopToFailWith :: forall err r. Member Fail r => (err -> Text) -> InterpreterFor (Stop err) r

+ Polysemy.Resume: stopToFailWith :: forall err (r :: EffectRow). Member (Fail :: (Type -> Type) -> Type -> Type) r => (err -> Text) -> InterpreterFor (Stop err) r

- Polysemy.Resume: stopToIOFinal :: forall err r a. Exception (StopExc err) => Member (Final IO) r => Sem (Stop err : r) a -> Sem r (Either err a)

+ Polysemy.Resume: stopToIOFinal :: forall err (r :: EffectRow) a. (Exception (StopExc err), Member (Final IO) r) => Sem (Stop err ': r) a -> Sem r (Either err a)

- Polysemy.Resume: stopTryAny :: forall err r a. Members [Stop err, Embed IO] r => (Text -> err) -> IO a -> Sem r a

+ Polysemy.Resume: stopTryAny :: forall err (r :: EffectRow) a. Members '[Stop err, Embed IO] r => (Text -> err) -> IO a -> Sem r a

- Polysemy.Resume: stopTryIO :: forall exc err r a. Exception exc => Members [Stop err, Embed IO] r => (Text -> err) -> IO a -> Sem r a

+ Polysemy.Resume: stopTryIO :: forall exc err (r :: EffectRow) a. (Exception exc, Members '[Stop err, Embed IO] r) => (Text -> err) -> IO a -> Sem r a

- Polysemy.Resume: stopTryIOE :: forall exc err r a. Exception exc => Members [Stop err, Embed IO] r => (exc -> err) -> IO a -> Sem r a

+ Polysemy.Resume: stopTryIOE :: forall exc err (r :: EffectRow) a. (Exception exc, Members '[Stop err, Embed IO] r) => (exc -> err) -> IO a -> Sem r a

- Polysemy.Resume: stopTryIOError :: forall err r a. Members [Stop err, Embed IO] r => (Text -> err) -> IO a -> Sem r a

+ Polysemy.Resume: stopTryIOError :: forall err (r :: EffectRow) a. Members '[Stop err, Embed IO] r => (Text -> err) -> IO a -> Sem r a

- Polysemy.Resume.Effect.Resumable: [Resumable] :: forall err eff r a. Weaving eff (Sem r) a -> Resumable err eff (Sem r) (Either err a)

+ Polysemy.Resume.Effect.Resumable: [Resumable] :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a1. Weaving eff (Sem r) a1 -> Resumable err eff (Sem r) (Either err a1)

- Polysemy.Resume.Effect.Resumable: data Resumable err eff :: Effect

+ Polysemy.Resume.Effect.Resumable: data Resumable err (eff :: Type -> Type -> Type -> Type) (a :: Type -> Type) b

- Polysemy.Resume.Effect.Stop: [Stop] :: e -> Stop e m a

+ Polysemy.Resume.Effect.Stop: [Stop] :: forall e (a :: Type -> Type) b. e -> Stop e a b

- Polysemy.Resume.Effect.Stop: data Stop e :: Effect

+ Polysemy.Resume.Effect.Stop: data Stop e (a :: Type -> Type) b

- Polysemy.Resume.Effect.Stop: stop :: forall e_a4EX r_a5Vr a_a4EZ. Member (Stop e_a4EX) r_a5Vr => e_a4EX -> Sem r_a5Vr a_a4EZ

+ Polysemy.Resume.Effect.Stop: stop :: forall e (r :: EffectRow) a. Member (Stop e) r => e -> Sem r a

- Polysemy.Resume.Interpreter.Resumable: catchResumable :: forall (err :: Type) (eff :: Effect) handled r. Members [eff, Error err] r => (err -> Maybe handled) -> InterpreterFor (Resumable handled eff) r

+ Polysemy.Resume.Interpreter.Resumable: catchResumable :: forall err (eff :: Effect) handled (r :: EffectRow). Members '[eff, Error err :: (Type -> Type) -> Type -> Type] r => (err -> Maybe handled) -> InterpreterFor (Resumable handled eff) r

- Polysemy.Resume.Interpreter.Resumable: interceptResumable :: forall (err :: Type) (eff :: Effect) (r :: EffectRow) (a :: Type). Member (Resumable err eff) r => FirstOrder eff "interceptResumable" => (forall x r0. eff (Sem r0) x -> Sem (Stop err : r) x) -> Sem r a -> Sem r a

+ Polysemy.Resume.Interpreter.Resumable: interceptResumable :: forall err eff (r :: EffectRow) a. (Member (Resumable err eff) r, FirstOrder eff "interceptResumable") => (forall x (r0 :: EffectRow). () => eff (Sem r0) x -> Sem (Stop err ': r) x) -> Sem r a -> Sem r a

- Polysemy.Resume.Interpreter.Resumable: interceptResumableH :: forall (err :: Type) (eff :: Effect) (r :: EffectRow) (a :: Type). Member (Resumable err eff) r => (forall x r0. eff (Sem r0) x -> Tactical (Resumable err eff) (Sem r0) (Stop err : r) x) -> Sem r a -> Sem r a

+ Polysemy.Resume.Interpreter.Resumable: interceptResumableH :: forall err eff (r :: EffectRow) a. Member (Resumable err eff) r => (forall x (r0 :: EffectRow). () => eff (Sem r0) x -> Tactical (Resumable err eff) (Sem r0) (Stop err ': r) x) -> Sem r a -> Sem r a

- Polysemy.Resume.Interpreter.Resumable: interceptResumableUsing :: forall (err :: Type) (eff :: Effect) (r :: EffectRow) (a :: Type). FirstOrder eff "interceptResumableUsing" => ElemOf (Resumable err eff) r -> (forall x r0. eff (Sem r0) x -> Sem (Stop err : r) x) -> Sem r a -> Sem r a

+ Polysemy.Resume.Interpreter.Resumable: interceptResumableUsing :: forall err eff (r :: EffectRow) a. FirstOrder eff "interceptResumableUsing" => ElemOf (Resumable err eff) r -> (forall x (r0 :: EffectRow). () => eff (Sem r0) x -> Sem (Stop err ': r) x) -> Sem r a -> Sem r a

- Polysemy.Resume.Interpreter.Resumable: interceptResumableUsingH :: forall (err :: Type) (eff :: Effect) (r :: EffectRow) (a :: Type). ElemOf (Resumable err eff) r -> (forall x r0. eff (Sem r0) x -> Tactical (Resumable err eff) (Sem r0) (Stop err : r) x) -> Sem r a -> Sem r a

+ Polysemy.Resume.Interpreter.Resumable: interceptResumableUsingH :: forall err eff (r :: EffectRow) a. ElemOf (Resumable err eff) r -> (forall x (r0 :: EffectRow). () => eff (Sem r0) x -> Tactical (Resumable err eff) (Sem r0) (Stop err ': r) x) -> Sem r a -> Sem r a

- Polysemy.Resume.Interpreter.Resumable: interpretResumable :: forall (err :: Type) (eff :: Effect) r. FirstOrder eff "interpretResumable" => (forall x r0. eff (Sem r0) x -> Sem (Stop err : r) x) -> InterpreterFor (Resumable err eff) r

+ Polysemy.Resume.Interpreter.Resumable: interpretResumable :: forall err eff (r :: [Effect]). FirstOrder eff "interpretResumable" => (forall x (r0 :: EffectRow). () => eff (Sem r0) x -> Sem (Stop err ': r) x) -> InterpreterFor (Resumable err eff) r

- Polysemy.Resume.Interpreter.Resumable: interpretResumableH :: forall (err :: Type) (eff :: Effect) (r :: EffectRow). (forall x r0. eff (Sem r0) x -> Tactical (Resumable err eff) (Sem r0) (Stop err : r) x) -> InterpreterFor (Resumable err eff) r

+ Polysemy.Resume.Interpreter.Resumable: interpretResumableH :: forall err eff (r :: EffectRow). (forall x (r0 :: EffectRow). () => eff (Sem r0) x -> Tactical (Resumable err eff) (Sem r0) (Stop err ': r) x) -> InterpreterFor (Resumable err eff) r

- Polysemy.Resume.Interpreter.Resumable: raiseResumable :: forall (err :: Type) (eff :: Effect) (r :: EffectRow). InterpreterTrans (Resumable err eff) eff r

+ Polysemy.Resume.Interpreter.Resumable: raiseResumable :: forall err (eff :: Effect) (r :: EffectRow) a b. (Sem (eff ': r) a -> Sem r b) -> Sem (Resumable err eff ': r) a -> Sem r b

- Polysemy.Resume.Interpreter.Resumable: resumable :: forall (err :: Type) (eff :: Effect) (r :: EffectRow). InterpreterFor eff (Stop err : r) -> InterpreterFor (Resumable err eff) r

+ Polysemy.Resume.Interpreter.Resumable: resumable :: forall err (eff :: Effect) (r :: EffectRow). InterpreterFor eff (Stop err ': r) -> InterpreterFor (Resumable err eff) r

- Polysemy.Resume.Interpreter.Resumable: resumableError :: forall (err :: Type) (eff :: Effect) r. InterpreterFor eff (Error err : (Stop err : r)) -> InterpreterFor (Resumable err eff) r

+ Polysemy.Resume.Interpreter.Resumable: resumableError :: forall err (eff :: Effect) (r :: [(Type -> Type) -> Type -> Type]). InterpreterFor eff ((Error err :: (Type -> Type) -> Type -> Type) ': (Stop err ': r)) -> InterpreterFor (Resumable err eff) r

- Polysemy.Resume.Interpreter.Resumable: resumableFor :: forall (err :: Type) (eff :: Effect) handled r. Member (Error err) r => (err -> Maybe handled) -> InterpreterFor eff (Stop err : r) -> InterpreterFor (Resumable handled eff) r

+ Polysemy.Resume.Interpreter.Resumable: resumableFor :: forall err (eff :: Effect) handled (r :: EffectRow). Member (Error err :: (Type -> Type) -> Type -> Type) r => (err -> Maybe handled) -> InterpreterFor eff (Stop err ': r) -> InterpreterFor (Resumable handled eff) r

- Polysemy.Resume.Interpreter.Resumable: resumableIO :: forall (err :: Type) (eff :: Effect) (r :: EffectRow). Exception (StopExc err) => Member (Final IO) r => InterpreterFor eff (Stop err : r) -> InterpreterFor (Resumable err eff) r

+ Polysemy.Resume.Interpreter.Resumable: resumableIO :: forall err (eff :: Effect) (r :: EffectRow). (Exception (StopExc err), Member (Final IO) r) => InterpreterFor eff (Stop err ': r) -> InterpreterFor (Resumable err eff) r

- Polysemy.Resume.Interpreter.Resumable: resumableOr :: forall (err :: Type) (eff :: Effect) unhandled handled r. Member (Error unhandled) r => (err -> Either unhandled handled) -> InterpreterFor eff (Stop err : r) -> InterpreterFor (Resumable handled eff) r

+ Polysemy.Resume.Interpreter.Resumable: resumableOr :: forall err (eff :: Effect) unhandled handled (r :: EffectRow). Member (Error unhandled :: (Type -> Type) -> Type -> Type) r => (err -> Either unhandled handled) -> InterpreterFor eff (Stop err ': r) -> InterpreterFor (Resumable handled eff) r

- Polysemy.Resume.Interpreter.Resumable: runAsResumable :: forall (err :: Type) (eff :: Effect) r. Members [Resumable err eff, Stop err] r => InterpreterFor eff r

+ Polysemy.Resume.Interpreter.Resumable: runAsResumable :: forall err (eff :: Effect) (r :: EffectRow). Members '[Resumable err eff, Stop err] r => InterpreterFor eff r

- Polysemy.Resume.Interpreter.Scoped: interpretResumableScoped :: forall param resource effect err r. (forall q x. param -> (resource -> Sem (Opaque q : r) x) -> Sem (Opaque q : r) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (Stop err : (Opaque q : r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

+ Polysemy.Resume.Interpreter.Scoped: interpretResumableScoped :: forall param resource effect err (r :: [Effect]). (forall (q :: Effect) x. () => param -> (resource -> Sem (Opaque q ': r) x) -> Sem (Opaque q ': r) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop err ': (Opaque q ': r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

- Polysemy.Resume.Interpreter.Scoped: interpretResumableScopedH :: forall param resource effect err r. (forall q x. param -> (resource -> Sem (Opaque q : r) x) -> Sem (Opaque q : r) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Tactical (effect !! err) (Sem r0) (Stop err : (Opaque q : r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

+ Polysemy.Resume.Interpreter.Scoped: interpretResumableScopedH :: forall param resource effect err (r :: [Effect]). (forall (q :: Effect) x. () => param -> (resource -> Sem (Opaque q ': r) x) -> Sem (Opaque q ': r) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Tactical (effect !! err) (Sem r0) (Stop err ': (Opaque q ': r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

- Polysemy.Resume.Interpreter.Scoped: interpretResumableScopedWith :: forall extra param resource effect err r. KnownList extra => (forall q x. param -> (resource -> Sem (extra ++ (Opaque q : r)) x) -> Sem (Opaque q : r) x) -> (forall r0 x. resource -> effect (Sem r0) x -> Sem (Stop err : (extra ++ r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

+ Polysemy.Resume.Interpreter.Scoped: interpretResumableScopedWith :: forall (extra :: [(Type -> Type) -> Type -> Type]) param resource effect err (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> (resource -> Sem (extra ++ (Opaque q ': r)) x) -> Sem (Opaque q ': r) x) -> (forall (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop err ': (extra ++ r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

- Polysemy.Resume.Interpreter.Scoped: interpretResumableScopedWithH :: forall extra param resource effect err r. KnownList extra => (forall q x. param -> (resource -> Sem (extra ++ (Opaque q : r)) x) -> Sem (Opaque q : r) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Tactical (effect !! err) (Sem r0) (Stop err : (extra ++ (Opaque q : r))) x) -> InterpreterFor (Scoped param (effect !! err)) r

+ Polysemy.Resume.Interpreter.Scoped: interpretResumableScopedWithH :: forall (extra :: [(Type -> Type) -> Type -> Type]) param resource effect err (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> (resource -> Sem (extra ++ (Opaque q ': r)) x) -> Sem (Opaque q ': r) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Tactical (effect !! err) (Sem r0) (Stop err ': (extra ++ (Opaque q ': r))) x) -> InterpreterFor (Scoped param (effect !! err)) r

- Polysemy.Resume.Interpreter.Scoped: interpretResumableScopedWith_ :: forall extra param effect err r. KnownList extra => (forall q x. param -> Sem (extra ++ (Opaque q : r)) x -> Sem (Opaque q : r) x) -> (forall r0 x. effect (Sem r0) x -> Sem (Stop err : (extra ++ r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

+ Polysemy.Resume.Interpreter.Scoped: interpretResumableScopedWith_ :: forall (extra :: [(Type -> Type) -> Type -> Type]) param effect err (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> Sem (extra ++ (Opaque q ': r)) x -> Sem (Opaque q ': r) x) -> (forall (r0 :: EffectRow) x. () => effect (Sem r0) x -> Sem (Stop err ': (extra ++ r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

- Polysemy.Resume.Interpreter.Scoped: interpretResumableScoped_ :: forall param resource effect err r. (param -> Sem r resource) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (Stop err : (Opaque q : r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

+ Polysemy.Resume.Interpreter.Scoped: interpretResumableScoped_ :: forall param resource effect err (r :: EffectRow). (param -> Sem r resource) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop err ': (Opaque q ': r)) x) -> InterpreterFor (Scoped param (effect !! err)) r

- Polysemy.Resume.Interpreter.Scoped: interpretScopedR :: forall param resource effect eo ei r. (forall q x. param -> (resource -> Sem (Stop eo : (Opaque q : r)) x) -> Sem (Stop eo : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (Stop ei : (Stop eo : (Opaque q : r))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

+ Polysemy.Resume.Interpreter.Scoped: interpretScopedR :: forall param resource effect eo ei (r :: [Effect]). (forall (q :: Effect) x. () => param -> (resource -> Sem (Stop eo ': (Opaque q ': r)) x) -> Sem (Stop eo ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop ei ': (Stop eo ': (Opaque q ': r))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

- Polysemy.Resume.Interpreter.Scoped: interpretScopedRH :: forall param resource effect eo ei r. (forall q x. param -> (resource -> Sem (Stop eo : (Opaque q : r)) x) -> Sem (Stop eo : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Tactical (effect !! ei) (Sem r0) (Stop ei : (Stop eo : (Opaque q : r))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

+ Polysemy.Resume.Interpreter.Scoped: interpretScopedRH :: forall param resource effect eo ei (r :: [Effect]). (forall (q :: Effect) x. () => param -> (resource -> Sem (Stop eo ': (Opaque q ': r)) x) -> Sem (Stop eo ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Tactical (effect !! ei) (Sem r0) (Stop ei ': (Stop eo ': (Opaque q ': r))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

- Polysemy.Resume.Interpreter.Scoped: interpretScopedRWith :: forall extra param resource effect eo ei r. KnownList extra => (forall q x. param -> (resource -> Sem (extra ++ (Stop eo : (Opaque q : r))) x) -> Sem (Stop eo : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (Stop ei : (extra ++ (Stop eo : (Opaque q : r)))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

+ Polysemy.Resume.Interpreter.Scoped: interpretScopedRWith :: forall (extra :: [(Type -> Type) -> Type -> Type]) param resource effect eo ei (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> (resource -> Sem (extra ++ (Stop eo ': (Opaque q ': r))) x) -> Sem (Stop eo ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop ei ': (extra ++ (Stop eo ': (Opaque q ': r)))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

- Polysemy.Resume.Interpreter.Scoped: interpretScopedRWithH :: forall extra param resource effect eo ei r. KnownList extra => (forall q x. param -> (resource -> Sem (extra ++ (Stop eo : (Opaque q : r))) x) -> Sem (Stop eo : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Tactical (effect !! ei) (Sem r0) (Stop ei : (extra ++ (Stop eo : (Opaque q : r)))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

+ Polysemy.Resume.Interpreter.Scoped: interpretScopedRWithH :: forall (extra :: [(Type -> Type) -> Type -> Type]) param resource effect eo ei (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> (resource -> Sem (extra ++ (Stop eo ': (Opaque q ': r))) x) -> Sem (Stop eo ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Tactical (effect !! ei) (Sem r0) (Stop ei ': (extra ++ (Stop eo ': (Opaque q ': r)))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

- Polysemy.Resume.Interpreter.Scoped: interpretScopedRWith_ :: forall extra param effect eo ei r. KnownList extra => (forall q x. param -> Sem (extra ++ (Stop eo : (Opaque q : r))) x -> Sem (Stop eo : (Opaque q : r)) x) -> (forall q r0 x. effect (Sem r0) x -> Sem (Stop ei : (extra ++ (Stop eo : (Opaque q : r)))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

+ Polysemy.Resume.Interpreter.Scoped: interpretScopedRWith_ :: forall (extra :: [(Type -> Type) -> Type -> Type]) param effect eo ei (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> Sem (extra ++ (Stop eo ': (Opaque q ': r))) x -> Sem (Stop eo ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => effect (Sem r0) x -> Sem (Stop ei ': (extra ++ (Stop eo ': (Opaque q ': r)))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

- Polysemy.Resume.Interpreter.Scoped: interpretScopedR_ :: forall param resource effect eo ei r. (param -> Sem (Stop eo : r) resource) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (Stop ei : (Stop eo : (Opaque q : r))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

+ Polysemy.Resume.Interpreter.Scoped: interpretScopedR_ :: forall param resource effect eo ei (r :: [(Type -> Type) -> Type -> Type]). (param -> Sem (Stop eo ': r) resource) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop ei ': (Stop eo ': (Opaque q ': r))) x) -> InterpreterFor (Scoped param (effect !! ei) !! eo) r

- Polysemy.Resume.Interpreter.Scoped: interpretScopedResumable :: forall param resource effect err r. (forall q x. param -> (resource -> Sem (Stop err : (Opaque q : r)) x) -> Sem (Stop err : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (Stop err : (Opaque q : r)) x) -> InterpreterFor (Scoped param effect !! err) r

+ Polysemy.Resume.Interpreter.Scoped: interpretScopedResumable :: forall param resource effect err (r :: [Effect]). (forall (q :: Effect) x. () => param -> (resource -> Sem (Stop err ': (Opaque q ': r)) x) -> Sem (Stop err ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop err ': (Opaque q ': r)) x) -> InterpreterFor (Scoped param effect !! err) r

- Polysemy.Resume.Interpreter.Scoped: interpretScopedResumableH :: forall param resource effect err r. (forall q x. param -> (resource -> Sem (Stop err : (Opaque q : r)) x) -> Sem (Stop err : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Tactical effect (Sem r0) (Stop err : (Opaque q : r)) x) -> InterpreterFor (Scoped param effect !! err) r

+ Polysemy.Resume.Interpreter.Scoped: interpretScopedResumableH :: forall param resource effect err (r :: [Effect]). (forall (q :: Effect) x. () => param -> (resource -> Sem (Stop err ': (Opaque q ': r)) x) -> Sem (Stop err ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Tactical effect (Sem r0) (Stop err ': (Opaque q ': r)) x) -> InterpreterFor (Scoped param effect !! err) r

- Polysemy.Resume.Interpreter.Scoped: interpretScopedResumableWith :: forall extra param resource effect err r. KnownList extra => (forall q x. param -> (resource -> Sem (extra ++ (Stop err : (Opaque q : r))) x) -> Sem (Stop err : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (extra ++ (Stop err : (Opaque q : r))) x) -> InterpreterFor (Scoped param effect !! err) r

+ Polysemy.Resume.Interpreter.Scoped: interpretScopedResumableWith :: forall (extra :: [(Type -> Type) -> Type -> Type]) param resource effect err (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> (resource -> Sem (extra ++ (Stop err ': (Opaque q ': r))) x) -> Sem (Stop err ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (extra ++ (Stop err ': (Opaque q ': r))) x) -> InterpreterFor (Scoped param effect !! err) r

- Polysemy.Resume.Interpreter.Scoped: interpretScopedResumableWithH :: forall extra param resource effect err r. KnownList extra => (forall q x. param -> (resource -> Sem (extra ++ (Stop err : (Opaque q : r))) x) -> Sem (Stop err : (Opaque q : r)) x) -> (forall q r0 x. resource -> effect (Sem r0) x -> Tactical effect (Sem r0) (extra ++ ([Stop err, Opaque q] ++ r)) x) -> InterpreterFor (Scoped param effect !! err) r

+ Polysemy.Resume.Interpreter.Scoped: interpretScopedResumableWithH :: forall (extra :: [(Type -> Type) -> Type -> Type]) param resource effect err (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> (resource -> Sem (extra ++ (Stop err ': (Opaque q ': r))) x) -> Sem (Stop err ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Tactical effect (Sem r0) (extra ++ ('[Stop err, Opaque q] ++ r)) x) -> InterpreterFor (Scoped param effect !! err) r

- Polysemy.Resume.Interpreter.Scoped: interpretScopedResumableWith_ :: forall extra param effect err r. KnownList extra => (forall q x. param -> Sem (extra ++ (Stop err : (Opaque q : r))) x -> Sem (Stop err : (Opaque q : r)) x) -> (forall q r0 x. effect (Sem r0) x -> Sem (extra ++ (Stop err : (Opaque q : r))) x) -> InterpreterFor (Scoped param effect !! err) r

+ Polysemy.Resume.Interpreter.Scoped: interpretScopedResumableWith_ :: forall (extra :: [(Type -> Type) -> Type -> Type]) param effect err (r :: [Effect]). KnownList extra => (forall (q :: Effect) x. () => param -> Sem (extra ++ (Stop err ': (Opaque q ': r))) x -> Sem (Stop err ': (Opaque q ': r)) x) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => effect (Sem r0) x -> Sem (extra ++ (Stop err ': (Opaque q ': r))) x) -> InterpreterFor (Scoped param effect !! err) r

- Polysemy.Resume.Interpreter.Scoped: interpretScopedResumable_ :: forall param resource effect err r. (forall q. param -> Sem (Stop err : (Opaque q : r)) resource) -> (forall q r0 x. resource -> effect (Sem r0) x -> Sem (Stop err : (Opaque q : r)) x) -> InterpreterFor (Scoped param effect !! err) r

+ Polysemy.Resume.Interpreter.Scoped: interpretScopedResumable_ :: forall param resource effect err (r :: [Effect]). (forall (q :: Effect). () => param -> Sem (Stop err ': (Opaque q ': r)) resource) -> (forall (q :: Effect) (r0 :: EffectRow) x. () => resource -> effect (Sem r0) x -> Sem (Stop err ': (Opaque q ': r)) x) -> InterpreterFor (Scoped param effect !! err) r

- Polysemy.Resume.Interpreter.Stop: mapStop :: forall err e' r a. Member (Stop e') r => (err -> e') -> Sem (Stop err : r) a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: mapStop :: forall err e' (r :: EffectRow) a. Member (Stop e') r => (err -> e') -> Sem (Stop err ': r) a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: replaceStop :: forall err e' r a. Member (Stop e') r => e' -> Sem (Stop err : r) a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: replaceStop :: forall err e' (r :: EffectRow) a. Member (Stop e') r => e' -> Sem (Stop err ': r) a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: runStop :: Sem (Stop err : r) a -> Sem r (Either err a)

+ Polysemy.Resume.Interpreter.Stop: runStop :: forall err (r :: [(Type -> Type) -> Type -> Type]) a. Sem (Stop err ': r) a -> Sem r (Either err a)

- Polysemy.Resume.Interpreter.Stop: runStopAsExcFinal :: forall err r a. Exception (StopExc err) => Member (Final IO) r => Sem (Stop err : r) a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: runStopAsExcFinal :: forall err (r :: EffectRow) a. (Exception (StopExc err), Member (Final IO) r) => Sem (Stop err ': r) a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: showStop :: forall err r a. Show err => Member (Stop Text) r => Sem (Stop err : r) a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: showStop :: forall err (r :: EffectRow) a. (Show err, Member (Stop Text) r) => Sem (Stop err ': r) a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: stopEither :: forall err r a. Member (Stop err) r => Either err a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: stopEither :: forall err (r :: EffectRow) a. Member (Stop err) r => Either err a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: stopEitherAs :: forall err err' r a. Member (Stop err') r => err' -> Either err a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: stopEitherAs :: forall err err' (r :: EffectRow) a. Member (Stop err') r => err' -> Either err a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: stopEitherWith :: forall err err' r a. Member (Stop err') r => (err -> err') -> Either err a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: stopEitherWith :: forall err err' (r :: EffectRow) a. Member (Stop err') r => (err -> err') -> Either err a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: stopNote :: forall err r a. Member (Stop err) r => err -> Maybe a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: stopNote :: forall err (r :: EffectRow) a. Member (Stop err) r => err -> Maybe a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: stopOnError :: forall err r a. Member (Stop err) r => Sem (Error err : r) a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: stopOnError :: forall err (r :: EffectRow) a. Member (Stop err) r => Sem ((Error err :: (Type -> Type) -> Type -> Type) ': r) a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: stopOnErrorWith :: forall err err' r a. Member (Stop err') r => (err -> err') -> Sem (Error err : r) a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: stopOnErrorWith :: forall err err' (r :: EffectRow) a. Member (Stop err') r => (err -> err') -> Sem ((Error err :: (Type -> Type) -> Type -> Type) ': r) a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: stopToError :: forall err r a. Member (Error err) r => Sem (Stop err : r) a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: stopToError :: forall err (r :: EffectRow) a. Member (Error err :: (Type -> Type) -> Type -> Type) r => Sem (Stop err ': r) a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: stopToErrorIO :: forall err r a. Exception (StopExc err) => Members [Error err, Final IO] r => Sem (Stop err : r) a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: stopToErrorIO :: forall err (r :: EffectRow) a. (Exception (StopExc err), Members '[Error err :: (Type -> Type) -> Type -> Type, Final IO] r) => Sem (Stop err ': r) a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: stopToErrorWith :: forall err err' r a. Member (Error err') r => (err -> err') -> Sem (Stop err : r) a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: stopToErrorWith :: forall err err' (r :: EffectRow) a. Member (Error err' :: (Type -> Type) -> Type -> Type) r => (err -> err') -> Sem (Stop err ': r) a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: stopToIOFinal :: forall err r a. Exception (StopExc err) => Member (Final IO) r => Sem (Stop err : r) a -> Sem r (Either err a)

+ Polysemy.Resume.Interpreter.Stop: stopToIOFinal :: forall err (r :: EffectRow) a. (Exception (StopExc err), Member (Final IO) r) => Sem (Stop err ': r) a -> Sem r (Either err a)

- Polysemy.Resume.Interpreter.Stop: stopTryAny :: forall err r a. Members [Stop err, Embed IO] r => (Text -> err) -> IO a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: stopTryAny :: forall err (r :: EffectRow) a. Members '[Stop err, Embed IO] r => (Text -> err) -> IO a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: stopTryIO :: forall exc err r a. Exception exc => Members [Stop err, Embed IO] r => (Text -> err) -> IO a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: stopTryIO :: forall exc err (r :: EffectRow) a. (Exception exc, Members '[Stop err, Embed IO] r) => (Text -> err) -> IO a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: stopTryIOE :: forall exc err r a. Exception exc => Members [Stop err, Embed IO] r => (exc -> err) -> IO a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: stopTryIOE :: forall exc err (r :: EffectRow) a. (Exception exc, Members '[Stop err, Embed IO] r) => (exc -> err) -> IO a -> Sem r a

- Polysemy.Resume.Interpreter.Stop: stopTryIOError :: forall err r a. Members [Stop err, Embed IO] r => (Text -> err) -> IO a -> Sem r a

+ Polysemy.Resume.Interpreter.Stop: stopTryIOError :: forall err (r :: EffectRow) a. Members '[Stop err, Embed IO] r => (Text -> err) -> IO a -> Sem r a

- Polysemy.Resume.Resume: (!!) :: forall err eff r a. Member (Resumable err eff) r => Sem (eff : r) a -> (err -> Sem r a) -> Sem r a

+ Polysemy.Resume.Resume: (!!) :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem (eff ': r) a -> (err -> Sem r a) -> Sem r a

- Polysemy.Resume.Resume: (!>) :: forall err eff r a. Member (Resumable err eff) r => Sem (eff : r) a -> a -> Sem r a

+ Polysemy.Resume.Resume: (!>) :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem (eff ': r) a -> a -> Sem r a

- Polysemy.Resume.Resume: (!>>) :: forall err eff r a. Member (Resumable err eff) r => Sem (eff : r) a -> Sem r a -> Sem r a

+ Polysemy.Resume.Resume: (!>>) :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem (eff ': r) a -> Sem r a -> Sem r a

- Polysemy.Resume.Resume: (<!) :: forall err eff r a. Member (Resumable err eff) r => a -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume.Resume: (<!) :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => a -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume.Resume: (<<!) :: forall err eff r a. Member (Resumable err eff) r => Sem r a -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume.Resume: (<<!) :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem r a -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume.Resume: restop :: forall err eff r. Members [Resumable err eff, Stop err] r => InterpreterFor eff r

+ Polysemy.Resume.Resume: restop :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow). Members '[Resumable err eff, Stop err] r => InterpreterFor eff r

- Polysemy.Resume.Resume: resume :: forall err eff r a. Member (Resumable err eff) r => Sem (eff : r) a -> (err -> Sem r a) -> Sem r a

+ Polysemy.Resume.Resume: resume :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem (eff ': r) a -> (err -> Sem r a) -> Sem r a

- Polysemy.Resume.Resume: resumeAs :: forall err eff r a. Member (Resumable err eff) r => a -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume.Resume: resumeAs :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => a -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume.Resume: resumeEither :: forall err eff r a. Member (Resumable err eff) r => Sem (eff : r) a -> Sem r (Either err a)

+ Polysemy.Resume.Resume: resumeEither :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem (eff ': r) a -> Sem r (Either err a)

- Polysemy.Resume.Resume: resumeError :: forall err eff r a. Members [Resumable err eff, Error err] r => Sem (eff : r) a -> Sem r a

+ Polysemy.Resume.Resume: resumeError :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Members '[Resumable err eff, Error err :: (Type -> Type) -> Type -> Type] r => Sem (eff ': r) a -> Sem r a

- Polysemy.Resume.Resume: resumeFail :: forall err eff r. Show err => Members [Fail, Resumable err eff] r => InterpreterFor eff r

+ Polysemy.Resume.Resume: resumeFail :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow). (Show err, Members '[Fail :: (Type -> Type) -> Type -> Type, Resumable err eff] r) => InterpreterFor eff r

- Polysemy.Resume.Resume: resumeFailWith :: forall err eff r. Members [Fail, Resumable err eff] r => (err -> Text) -> InterpreterFor eff r

+ Polysemy.Resume.Resume: resumeFailWith :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow). Members '[Fail :: (Type -> Type) -> Type -> Type, Resumable err eff] r => (err -> Text) -> InterpreterFor eff r

- Polysemy.Resume.Resume: resumeHoist :: forall err eff err' r a. Members [Resumable err eff, Stop err'] r => (err -> err') -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume.Resume: resumeHoist :: forall err (eff :: (Type -> Type) -> Type -> Type) err' (r :: EffectRow) a. Members '[Resumable err eff, Stop err'] r => (err -> err') -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume.Resume: resumeHoistAs :: forall err eff err' r. Members [Resumable err eff, Stop err'] r => err' -> InterpreterFor eff r

+ Polysemy.Resume.Resume: resumeHoistAs :: forall err (eff :: (Type -> Type) -> Type -> Type) err' (r :: EffectRow). Members '[Resumable err eff, Stop err'] r => err' -> InterpreterFor eff r

- Polysemy.Resume.Resume: resumeHoistError :: forall err eff err' r a. Members [Resumable err eff, Error err'] r => (err -> err') -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume.Resume: resumeHoistError :: forall err (eff :: (Type -> Type) -> Type -> Type) err' (r :: EffectRow) a. Members '[Resumable err eff, Error err' :: (Type -> Type) -> Type -> Type] r => (err -> err') -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume.Resume: resumeHoistErrorAs :: forall err eff err' r a. Members [Resumable err eff, Error err'] r => err' -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume.Resume: resumeHoistErrorAs :: forall err (eff :: (Type -> Type) -> Type -> Type) err' (r :: EffectRow) a. Members '[Resumable err eff, Error err' :: (Type -> Type) -> Type -> Type] r => err' -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume.Resume: resumeMaybe :: forall err eff r a. Member (Resumable err eff) r => Sem (eff : r) a -> Sem r (Maybe a)

+ Polysemy.Resume.Resume: resumeMaybe :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem (eff ': r) a -> Sem r (Maybe a)

- Polysemy.Resume.Resume: resumeOr :: forall err eff r a b. Member (Resumable err eff) r => Sem (eff : r) a -> (a -> Sem r b) -> (err -> Sem r b) -> Sem r b

+ Polysemy.Resume.Resume: resumeOr :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a b. Member (Resumable err eff) r => Sem (eff ': r) a -> (a -> Sem r b) -> (err -> Sem r b) -> Sem r b

- Polysemy.Resume.Resume: resumeRe :: forall err eff r a. Sem (eff : r) a -> (err -> Sem (Resumable err eff : r) a) -> Sem (Resumable err eff : r) a

+ Polysemy.Resume.Resume: resumeRe :: forall err (eff :: Effect) (r :: [Effect]) a. Sem (eff ': r) a -> (err -> Sem (Resumable err eff ': r) a) -> Sem (Resumable err eff ': r) a

- Polysemy.Resume.Resume: resumeWith :: forall err eff r a. Member (Resumable err eff) r => Sem (eff : r) a -> Sem r a -> Sem r a

+ Polysemy.Resume.Resume: resumeWith :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem (eff ': r) a -> Sem r a -> Sem r a

- Polysemy.Resume.Resume: resume_ :: forall err eff r. Member (Resumable err eff) r => Sem (eff : r) () -> Sem r ()

+ Polysemy.Resume.Resume: resume_ :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow). Member (Resumable err eff) r => Sem (eff ': r) () -> Sem r ()

- Polysemy.Resume.Resume: resuming :: forall err eff r a. Member (Resumable err eff) r => (err -> Sem r a) -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume.Resume: resuming :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => (err -> Sem r a) -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume.Resume: resumingOr :: forall err eff r a b. Member (Resumable err eff) r => (err -> Sem r b) -> Sem (eff : r) a -> (a -> Sem r b) -> Sem r b

+ Polysemy.Resume.Resume: resumingOr :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a b. Member (Resumable err eff) r => (err -> Sem r b) -> Sem (eff ': r) a -> (a -> Sem r b) -> Sem r b

- Polysemy.Resume.Resume: resumingRe :: forall err eff r a. (err -> Sem (Resumable err eff : r) a) -> Sem (eff : r) a -> Sem (Resumable err eff : r) a

+ Polysemy.Resume.Resume: resumingRe :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: [(Type -> Type) -> Type -> Type]) a. (err -> Sem (Resumable err eff ': r) a) -> Sem (eff ': r) a -> Sem (Resumable err eff ': r) a

- Polysemy.Resume.Resume: resumingWith :: forall err eff r a. Member (Resumable err eff) r => Sem r a -> Sem (eff : r) a -> Sem r a

+ Polysemy.Resume.Resume: resumingWith :: forall err (eff :: (Type -> Type) -> Type -> Type) (r :: EffectRow) a. Member (Resumable err eff) r => Sem r a -> Sem (eff ': r) a -> Sem r a

- Polysemy.Resume.Resume: stopToFail :: forall err r. Show err => Member Fail r => InterpreterFor (Stop err) r

+ Polysemy.Resume.Resume: stopToFail :: forall err (r :: EffectRow). (Show err, Member (Fail :: (Type -> Type) -> Type -> Type) r) => InterpreterFor (Stop err) r

- Polysemy.Resume.Resume: stopToFailWith :: forall err r. Member Fail r => (err -> Text) -> InterpreterFor (Stop err) r

+ Polysemy.Resume.Resume: stopToFailWith :: forall err (r :: EffectRow). Member (Fail :: (Type -> Type) -> Type -> Type) r => (err -> Text) -> InterpreterFor (Stop err) r

Files

polysemy-resume.cabal +6/−6

polysemy-resume.cabal view

@@ -1,11 +1,11 @@ cabal-version: 2.2 --- This file has been generated from package.yaml by hpack version 0.36.0.+-- This file has been generated from package.yaml by hpack version 0.36.1. -- -- see: https://github.com/sol/hpack  name:           polysemy-resume-version:        0.9.0.0+version:        0.9.0.1 synopsis:       Polysemy error tracking description:    See https://hackage.haskell.org/package/polysemy-resume/docs/Polysemy-Resume.html category:       Error@@ -13,7 +13,7 @@ bug-reports:    https://github.com/tek/polysemy-resume/issues author:         Torsten Schmits maintainer:     hackage@tryp.io-copyright:      2023 Torsten Schmits+copyright:      2025 Torsten Schmits license:        BSD-2-Clause-Patent license-file:   LICENSE build-type:     Simple@@ -74,7 +74,7 @@       NoFieldSelectors   ghc-options: -Wall -Widentities -Wincomplete-uni-patterns -Wmissing-deriving-strategies -Wredundant-constraints -Wunused-type-patterns -Wunused-packages   build-depends:-      base >=4.16.4.0 && <4.20+      base >=4.16.4.0 && <4.21     , incipit-core >=0.4.1.0 && <0.7     , polysemy >=1.9.0.0 && <1.10     , transformers >=0.5.6.2 && <0.7@@ -132,14 +132,14 @@       NoFieldSelectors   ghc-options: -threaded -rtsopts -with-rtsopts=-N -Wall -Widentities -Wincomplete-uni-patterns -Wmissing-deriving-strategies -Wredundant-constraints -Wunused-type-patterns -Wunused-packages   build-depends:-      base >=4.16.4.0 && <4.20+      base >=4.16.4.0 && <4.21     , incipit-core >=0.4.1.0 && <0.7     , polysemy >=1.9.0.0 && <1.10     , polysemy-plugin >=0.4.3.0 && <0.5     , polysemy-resume     , polysemy-test >=0.6.0.0 && <0.11     , stm >=2.5.0.2 && <2.6-    , tasty >=1.4.0.3 && <1.5+    , tasty >=1.4.0.3 && <1.6   mixins:       base hiding (Prelude)     , incipit-core (IncipitCore as Prelude)