Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
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