| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
RequireCallStack
Description
This module provides utilities to ensure that you propagate
HasCallStack constraints by introducing a class RequireCallStack
which can only be discharged using the provideCallStack function.
Let's say you have a custom prelude for your project, and you want
better callstack support. You replace the error with a custom
variant:
error :: RequireCallStack => String -> a error = Prelude.error
Now, you will receive a compile-time error at every use site of error
in your project. These errors will complain about a missing instance of
some weird class that gently suggests to add a RequireCallStack
constraint, or use provideCallStack to discharge it. You can add
RequireCallStack constraints up the stack, until eventually, you have
complete provenance information. Or, if you want to make the work a bit
easier, you can use provideCallStack to dismiss the constraint.
foo :: RequireCallStack => Int -> String foo = error "oh no" bar :: Int -> String bar i = provideCallStack $ foo i
Couple this with annotated-exception library for excellent provenance
information on all thrown exceptions.
Synopsis
Documentation
type RequireCallStack = (HasCallStack, RequireCallStackImpl) Source #
This constraint is similar to HasCallStack in that it's presence
will capture a stack frame for the call site of the function. This helps
to preserve callstack provenance, which
Since: 0.1.0.0
type RequireCallStackImpl = Add_RequireCallStack_ToFunctionContext_OrUse_provideCallStack Source #
An alias to make referring to
Add_RequireCallStack_ToFunctionContext_OrUse_provideCallStack easier,
since it is a bit of a mouthful.
If you see this, you probably need to either add RequireCallStack to
the function constraints, or you need to call provideCallStack to
discharge it.
Since: 0.1.0.0
provideCallStack :: HasCallStack => (RequireCallStackImpl => r) -> r Source #
Satisfy a RequireCallStack constraint for the given block. Can be
used instead of propagating a RequireCallStack up the call graph.
Usage:
main :: IO ()
main = do
provideCallStack $ do
errorRequireCallStack "hello"
Note how main does not have a HasCallStack or RequireCallStack
constraint. This function eliminates them, so that
errorRequireCallStack can be called without compilation error.
Since: 0.1.0.0
errorRequireCallStack :: RequireCallStack => String -> x Source #
Raise an ErrorCall and incur a RequireCallStack constraint while
you do so. This
Since: 0.1.0.0