h$W7      !"#$%&'()*+,-./0123456 Safe-Inferred '(-/2?j annotated-exceptionA wrapper type for putting a 7 into an  . We need this because 7 does not have an 8 instance. annotated-exceptionAn  - is a wrapper around a value that includes a 9 constraint so we can later unpack it. It is essentially a 'Dynamic, but we also include : and 8 so it's more useful.annotated-exception)The constraints that the value inside an   must have.We want 9 so we can do ;8 and potentially get more useful information out of it.annotated-exceptionWrap a value in an  .annotated-exception Attempt to ; the underlying value out of an  .annotated-exception Attempt to ; the underlying value out of an  . Returns the original   if the cast isn't right.annotated-exception Attempt to ; list of   into the given type. Any  , that is not in that form is left untouched.annotated-exception Returns the <, of types that are in the given annotations.annotated-exceptionMap a function over the given  =. If the types don't match up, then the whole thing returns =.annotated-exceptionMap a function over the  1, leaving it unchanged if the types don't match.annotated-exceptionGrab an   corresponding to the 7 that is currently in scope.annotated-exceptionStuff a 7 into an   via the   newtype wrapper.annotated-exceptionAttempt to convert an   back into a 7.annotated-exception Extract the 7 s from the [ ]. Any   not corresponding to a 7- will be in the second element of the tuple.annotated-exceptionannotated-exceptionannotated-exception>?@AB   Safe-Inferred'(02567>?annotated-exceptionThe  type wraps an  exception with a [ ]. This can provide a sort of a manual stack trace with programmer provided data.#annotated-exceptionAttach an empty [ ] to an exception.$annotated-exceptionCall  toException on the underlying .%annotated-exceptionCall  fromException on the underlying +, attaching the annotations to the result.&annotated-exception)Catch an exception. This works just like C%, but it also will attempt to catch  e. The annotations will be preserved in the handler, so rethrowing exceptions will retain the context.Let's consider a few examples, that share this import and exception type. import qualified Control.Exception.Safe as Safe import Control.Exception.Annotated data TestException deriving (Show, Exception)0We can throw an exception and catch it as usual. throw TestException `catch` \TestException -> putStrLn "ok!"5We can throw an exception and catch it with location. throw TestException `catch` \(AnnotatedException anns TestException) -> putStrLn "ok!",We can throw an exception and catch it as a  . throw TestException `catch` \(AnnotatedException anns (e :: SomeException) -> putStrLn "ok!"'annotated-exceptionLike &, but always returns a .(annotated-exceptionLike D, but can also handle an 3 or the underlying value. Useful when you want to (? to catch a type of exception, but you may not care about the  s that it may or may not have.Example: Left exn <- try $ throw (AnnotatedException [] TestException) exn == TestException Left exn <- try $ throw TestException exn == AnnotatedException [] TestException)annotated-exception Attaches the 7 to the  that is thrown.The 7 will *not* be present as a 7 - it will be a  .*annotated-exception Add a single  3 to any exceptions thrown in the following action.Example: main = do checkpoint "Foo" $ do print =<< readFile "I don't exist.markdown"?@ABCDEFGHIJKLMLNLNLOLO+-PQRSTUVW2annotated-exception-0.1.1.0-5gfmagBQP5oAqmLASZtHDYControl.Exception.AnnotatedData.AnnotationPaths_annotated_exceptionbaseGHC.Exception.Type SomeExceptiondisplayException fromException toException Exceptionexceptions-0.10.4Control.Monad.CatchHandler.safe-exceptions-0.1.7.2-JneZS63Oo6PChwawONXlrZControl.Exception.SafethrowCallStackAnnotationunCallStackAnnotation AnnotationAnnC toAnnotationcastAnnotation tryAnnotationtryAnnotationsannotationTypes mapAnnotationmapMaybeAnnotationcallStackAnnotationcallStackToAnnotationcallStackFromAnnotationcallStackInAnnotations$fIsStringAnnotation$fShowAnnotation$fEqAnnotation$fEqCallStackAnnotation$fShowCallStackAnnotationAnnotatedException annotations exceptionnewhidecheckcatch tryAnnotatedtrythrowWithCallStack checkpointcheckpointCallStackWithcheckpointCallStackcheckpointManyannotatedExceptionCallStackaddCallStackToException$fExceptionAnnotatedException$fApplicativeAnnotatedException$fEqAnnotatedException$fShowAnnotatedException$fFunctorAnnotatedException$fFoldableAnnotatedException$fTraversableAnnotatedExceptionGHC.Stack.Types CallStackghc-prim GHC.ClassesEqData.Typeable.InternalTypeableGHC.ShowShow Data.Typeablecastcontainers-0.6.2.1Data.Set.InternalSet GHC.MaybeNothing Data.Proxy asProxyTypeOfProxyKProxyversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName