Infix alias for Resumable.

Member (Stopper !! Boom) r =>

Effect that wraps another effect eff, marking it as throwing errors of type err using Stop.

Execute the action of a regular effect eff so that any error of type err that maybe be thrown by the (unknown) interpreter used for eff will be caught here and handled by the handler argument. This is similar to catch with the additional guarantee that the error will have to be explicitly matched, therefore preventing accidental failure to handle an error and bubbling it up to main. It also imposes a membership of Resumable err eff on the program, requiring the interpreter for eff to be adapted with resumable.

data Resumer :: Effect where
  MainProgram :: Resumer m Int

makeSem ''Resumer

interpretResumer ::
  Member (Resumable Boom Stopper) r =>
  InterpreterFor Resumer r
interpretResumer =
  interpret \ MainProgram ->
    resume (192 <$ stopBang) \ _ ->
      pure 237

Operator version of resume.

Since: 0.2.0.0

Create an interpreter for Resumable err eff by supplying a handler function for eff, analogous to interpret. If the handler throws errors with Stop, they will be absorbed into Resumable, to be caught by resume in a downstream interpreter.

interpretStopperResumable ::
  InterpreterFor Stopper r
interpretStopperResumable =
  interpretResumable \case
    StopBang -> stop (Bang 13)
    StopBoom -> stop (Boom "ouch")

>>> run $ interpretStopperResumable (interpretResumer mainProgram)
237

Like interpretResumable, but for higher-order effects.

Interceptor variant of interpretResumable.

Interceptor variant of interpretResumableH.

Interceptor variant of interpretResumable.

Interceptor variant of interpretResumableH.

Convert a bare interpreter for eff, which (potentially) uses Stop to signal errors, into an interpreter for Resumable. Beware: This will display unsound behaviour if: * the interpreter is wrapped with actions of another effect, as in:

  interpretEff :: InterpreterFor Eff r
  ...

  interpretEffResumable :: InterpreterFor (Resumable Text Eff) r
  interpretEffResumable sem =
  resumable (interpretEff (sem finally releaseResources))
  

In this case, releaseResources will be called after every use of Eff in sem, not after the entire thunk.

• the interpreter of a higher-order effect uses a different interpreter after using runT/bindT. In this case, it will use the original interpreter instead.

If your use case matches one of these conditions, you'll need to use interpretResumable.

>>> run $ resumable interpretStopper (interpretResumer mainProgram)
237

Convenience combinator for turning an interpreter that doesn't use Stop into a Resumable.

Like resumable, but use exceptions instead of ExceptT.

Combined interpreter for Scoped and Resumable. This allows Stop to be sent from within the resource allocator so that the consumer receives it, terminating the entire scope.

Combined higher-order interpreter for Scoped and Resumable. This allows Stop to be sent from within the resource allocator so that the consumer receives it, terminating the entire scope.

Combined interpreter for Scoped and Resumable. This allows Stop to be sent from within the resource allocator so that the consumer receives it, terminating the entire scope. In this variant, the resource allocator is a plain action.

Combined interpreter for Scoped and Resumable that allows the handler to use additional effects that are interpreted by the resource allocator. This allows Stop to be sent from within the resource allocator so that the consumer receives it, terminating the entire scope.

Combined higher-order interpreter for Scoped and Resumable that allows the handler to use additional effects that are interpreted by the resource allocator. This allows Stop to be sent from within the resource allocator so that the consumer receives it, terminating the entire scope.

Combined interpreter for Scoped and Resumable that allows the handler to use additional effects that are interpreted by the resource allocator. This allows Stop to be sent from within the resource allocator so that the consumer receives it, terminating the entire scope. In this variant, no resource is used and the allocator is a plain interpreter.

Combined interpreter for Resumable and Scoped. In this variant, only the handler may send Stop, but this allows resumption to happen on each action inside of the scope.

Combined higher-order interpreter for Resumable and Scoped. In this variant, only the handler may send Stop, but this allows resumption to happen on each action inside of the scope.

Combined interpreter for Resumable and Scoped. In this variant: - Only the handler may send Stop, but this allows resumption to happen on each action inside of the scope. - The resource allocator is a plain action.

Combined interpreter for Resumable and Scoped that allows the handler to use additional effects that are interpreted by the resource allocator. In this variant, only the handler may send Stop, but this allows resumption to happen on each action inside of the scope.

Combined higher-order interpreter for Resumable and Scoped that allows the handler to use additional effects that are interpreted by the resource allocator. In this variant, only the handler may send Stop, but this allows resumption to happen on each action inside of the scope.

Combined interpreter for Resumable and Scoped that allows the handler to use additional effects that are interpreted by the resource allocator. In this variant: - Only the handler may send Stop, but this allows resumption to happen on each action inside of the scope. - No resource is used and the allocator is a plain interpreter.

Combined interpreter for Scoped and Resumable. In this variant, both the handler and the scope may send different errors via Stop, encoding the concept that the resource allocation may fail to prevent the scope from being executed, and each individual scoped action may fail, continuing the scope execution on resumption.

Combined higher-order interpreter for Resumable and Scoped. In this variant, both the handler and the scope may send different errors via Stop, encoding the concept that the resource allocation may fail to prevent the scope from being executed, and each individual scoped action may fail, continuing the scope execution on resumption.

Combined interpreter for Scoped and Resumable. In this variant: - Both the handler and the scope may send different errors via Stop, encoding the concept that the resource allocation may fail to prevent the scope from being executed, and each individual scoped action may fail, continuing the scope execution on resumption. - The resource allocator is a plain action.

Combined interpreter for Scoped and Resumable that allows the handler to use additional effects that are interpreted by the resource allocator. In this variant, both the handler and the scope may send different errors via Stop, encoding the concept that the resource allocation may fail to prevent the scope from being executed, and each individual scoped action may fail, continuing the scope execution on resumption.

Combined higher-order interpreter for Scoped and Resumable that allows the handler to use additional effects that are interpreted by the resource allocator. In this variant, both the handler and the scope may send different errors via Stop, encoding the concept that the resource allocation may fail to prevent the scope from being executed, and each individual scoped action may fail, continuing the scope execution on resumption.

Combined interpreter for Scoped and Resumable that allows the handler to use additional effects that are interpreted by the resource allocator. - Both the handler and the scope may send different errors via Stop, encoding the concept that the resource allocation may fail to prevent the scope from being executed, and each individual scoped action may fail, continuing the scope execution on resumption. - The resource allocator is a plain action.

Convert an interpreter for eff that throws errors of type err into a Resumable, but limiting the errors handled by consumers to the type handled, which rethrowing Errors of type unhandled.

The function canHandle determines how the errors are split.

newtype Blip =
  Blip { unBlip :: Int }
  deriving stock (Eq, Show)

bangOnly :: Boom -> Either Text Blip
bangOnly = \case
  Bang n -> Right (Blip n)
  Boom msg -> Left msg

interpretResumerPartial ::
  Member (Resumable Blip Stopper) r =>
  InterpreterFor Resumer r
interpretResumerPartial =
  interpret \ MainProgram ->
    resume (192 <$ stopBang) \ (Blip num) ->
      pure (num * 3)

>>> runError (resumableFor bangOnly interpretStopper (interpretResumerPartial mainProgram))
Right 39

Variant of resume that unconditionally recovers with a constant value.

Operator version of resumeAs.

Since: 0.2.0.0

Operator version of resumeAs, flipped version of (<!).

Since: 0.2.0.0

Variant of resume that unconditionally recovers with an action.

Since: 0.2.0.0

Operator variant of resumeWith.

Since: 0.2.0.0

Variant of resuming that unconditionally recovers with an action.

Since: 0.2.0.0

Operator variant of resumingWith.

Since: 0.2.0.0

Convenience specialization of resume that silently discards errors for void programs.

Variant of resume that propagates the error to another Stop effect after applying a function.

Variant of resumeHoist that uses a constant value.

Flipped variant of resume.

Variant of resume that propagates the error to an Error effect after applying a function.

Variant of resumeHoistError that uses the unchanged error.

Variant of resumeHoist that uses the unchanged error.

Variant of resume that immediately produces an Either.

Variant of resume that immediately produces an Maybe.

Variant of resume that takes a branch for error and success. This allows the success branch to contain other resumptions.

Since: 0.2.0.0

Variant of resuming that takes a branch for error and success. This allows the success branch to contain other resumptions.

Since: 0.2.0.0

Variant of resumeHoistError that uses the unchanged error.

Convert an interpreter for eff that uses Error into one using Stop and wrap it using resumable.

Variant of resumableOr that uses Maybe and rethrows the original error.

Interpret an effect eff by wrapping it in Resumable and Stop and leaving the rest up to the user.

Reinterpreting variant of resumableFor.

Transform Stop to Fail using the supplied error message rendering function.

Transform Stop to Fail using show.

Resume a computation, converting Stop to Fail.

Resume a computation, converting Stop to Fail using show.

Map over the error type in a Stop.

Replace the error in a Stop with another type.

Equivalent of runError.

Convert the error type in a Stop to Text.

Stop if the argument is Left.

Stop if the argument is Left, using the supplied error.

Stop if the argument is Left, transforming the error with f.

Stop with the supplied error if the argument is Nothing.

Convert a program using regular Errors to one using Stop.

Convert a program using regular Errors to one using Stop.

Convert a program using Stop to one using Error.

Convert a program using Stop to one using Error.

Convert a program using Stop to one using Error, transforming the error with the supplied function.

Run Stop by throwing and catching exceptions.

Convert an IO exception to Stop using the provided transformation from Text.

Convert an IO exception of type err to Stop using the provided transformation from Text.

Convert an IO exception to Stop using the provided transformation.

Convert an IO exception of type IOError to Stop using the provided transformation from Text.