h$      !"#$%&'()*+,-./0123456789:;<=>?@ABCD Safe-Inferred '(-/2? annotated-exceptionA wrapper type for putting a E into an . We need this because E does not have an F instance.annotated-exceptionAn - is a wrapper around a value that includes a G constraint so we can later unpack it. It is essentially a 'Dynamic, but we also include H and F so it's more useful.annotated-exception)The constraints that the value inside an  must have.We want G so we can do I8 and potentially get more useful information out of it.annotated-exceptionWrap a value in an .annotated-exception Attempt to I the underlying value out of an .annotated-exception Attempt to I the underlying value out of an . Returns the original  if the cast isn't right.annotated-exception Attempt to I list of  into the given type. Any , that is not in that form is left untouched.annotated-exception Returns the J, 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 K.annotated-exceptionMap a function over the 1, leaving it unchanged if the types don't match.annotated-exceptionGrab an  corresponding to the E that is currently in scope.annotated-exceptionStuff a E into an  via the   newtype wrapper.annotated-exceptionAttempt to convert an  back into a E.annotated-exception Extract the E s from the []. Any  not corresponding to a E- will be in the second element of the tuple.annotated-exceptionannotated-exception annotated-exceptionLMNOP   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 Q%, 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 R), but this function enhance the provided  s to "see through" any #s.,annotated-exceptionLike *, but always returns a #.-annotated-exceptionLike S, 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 E to the # that is thrown.The E will *not* be present as a E - 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"annotated-exceptionLike / , but uses   instead of  MonadCatch.?annotated-exceptionLike 2 , but uses   instead of  MonadCatch.@annotated-exceptionLike 0 , but uses   instead of  MonadCatch.Aannotated-exceptionLike * , but uses   instead of  MonadCatch.Bannotated-exceptionLike , but uses   instead of  MonadCatch.Cannotated-exceptionLike - but uses   instead of  MonadCatch.Dannotated-exceptionLike + , bt uses   instead of  MonadCatch.$  #$&%'()134<=>?@ABCD$#$&%'<>?1@ADBC)(34 =   Safe-InferredTUVWXYZ[         !"#$%&'()*+,--./0123456789:;<=>?@ABCD78;93564EFGHIJKLMNOPQRSTUVUWUWUXUX346YZ[\]^_`2annotated-exception-0.1.2.0-2MRvQwn4cSo6Lz6xdhkIFq$Control.Exception.Annotated.UnliftIOControl.Exception.AnnotatedData.AnnotationPaths_annotated_exceptionbaseControl.Monad.IO.ClassliftIOMonadIOGHC.Exception.Type SomeExceptiondisplayException fromException toException Exceptionexceptions-0.10.4Control.Monad.CatchHandler.safe-exceptions-0.1.7.2-JneZS63Oo6PChwawONXlrZControl.Exception.Safethrow,unliftio-core-0.2.0.1-9GVcmaajsglG88oErAZOTVControl.Monad.IO.Unlift withRunInIO MonadUnliftIOCallStackAnnotationunCallStackAnnotation AnnotationAnnC toAnnotationcastAnnotation tryAnnotationtryAnnotationsannotationTypes mapAnnotationmapMaybeAnnotationcallStackAnnotationcallStackToAnnotationcallStackFromAnnotationcallStackInAnnotations$fIsStringAnnotation$fShowAnnotation$fEqAnnotation$fEqCallStackAnnotation$fShowCallStackAnnotationAnnotatedException annotations exceptionnewhidecheckcatchcatches 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