h*#A!Z      !"#$%&'()*+,-./0123456789:;<=>?@ABC0.3.0.1 Safe-Inferred )*/16  annotated-exceptionA wrapper type for putting a D into an . We need this because D does not have an E instance./Deprecated in 0.2.0.0 since you can just put a D directly in an ! now that we have no need for an E constraint on it.annotated-exceptionAn - is a wrapper around a value that includes a F< constraint so we can later unpack it. It is essentially a , but we also include G, so that you can always fall back to simply H ing the ! if it is otherwise unrecognized.annotated-exception)The constraints that the value inside an  must have.We want F 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 D that is currently in scope.annotated-exceptionStuff a D into an  via the   newtype wrapper.annotated-exceptionConvert the legacy   into a D.(Deprecated in 0.2.0.0 since you can use D directly.annotated-exception Extract the D s from the []. Any  not corresponding to a D- will be in the second element of the tuple.annotated-exceptionannotated-exception LMNOP  Safe-Inferred%&)*369:;!annotated-exceptionThe ! type wraps an  exception with a []. This can provide a sort of a manual stack trace with programmer provided data.%annotated-exception)Annotate the underlying exception with a D.Qannotated-exception Append the [] to the !.D is a special case - if a D is present in both the ! and the [], then this will append the D4s in the new list and concatenate them all together.&annotated-exceptionCall  on the underlying .'annotated-exceptionCall  on the underlying +, attaching the annotations to the result.(annotated-exception)Catch an exception. This works just like R%, 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!"8We can throw an exception and catch it with annotations. 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 S), but this function enhance the provided s to "see through" any !s.Tannotated-exception Extends each 3 in the list with a variant that sees through the !* and re-annotates any rethrown exceptions.*annotated-exceptionLike (, but always returns a !.+annotated-exceptionLike U, 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 Throws an # and annotates it with the current D. An alias for -.-annotated-exception Attaches the D to the ! that is thrown.Vannotated-exception%Concatenate two lists of annotations..annotated-exception Add a single 8 to any exceptions thrown in the following action. The D present on any !0 will also be updated to include this location.Example: main = do checkpoint "Foo" $ do print =<< readFile "I don't exist.markdown"annotated-exceptionLike 1 , but uses   instead of  .?annotated-exceptionLike / , but uses   instead of  .0Deprecated in 0.2.0.0 as it is now an alias for >.@annotated-exceptionLike ( , but uses   instead of  .Aannotated-exceptionLike * but uses   instead of  .Bannotated-exceptionLike + but uses   instead of  .Cannotated-exceptionLike ) , bt uses   instead of  .$!"$#%:<>=?@CAB'&23 ;  $!"$#%:<>=?@CAB'&23 ;   Safe-Inferred!MYZ[\]^_`         !"#$%&'()*+,-../0123456789:;<=>?@ABCDE98:<=;4675 FGHIJ KL MN MO PQRST UV WX WX WY WY WZ[\]4\]5^\]7_ F`a b c d e f g h i2annotated-exception-0.3.0.1-DHjSSOvwyZk9Pz0ASlsnmsControl.Exception.Annotated$Control.Exception.Annotated.UnliftIOData.Annotationannotated-exception Data.DynamicDynamicControl.Monad.Catch MonadThrow MonadCatchPaths_annotated_exceptionbaseGHC.Exception.Type SomeException Exception toException fromExceptiondisplayExceptionControl.Monad.IO.ClassMonadIOliftIOexceptions-0.10.7Handler,unliftio-core-0.2.1.0-C9JgChpS9UyE1Qndi71slPControl.Monad.IO.Unlift MonadUnliftIO withRunInIOCallStackAnnotationunCallStackAnnotation AnnotationAnnC toAnnotationcastAnnotation tryAnnotationtryAnnotationsannotationTypes mapAnnotationmapMaybeAnnotationcallStackAnnotationcallStackToAnnotationcallStackFromAnnotationcallStackInAnnotations$fIsStringAnnotation$fShowAnnotation$fEqCallStackAnnotation$fShowCallStackAnnotationAnnotatedException annotations exceptionexceptionWithCallStackhidecheckcatchcatches tryAnnotatedtrythrowthrowWithCallStack checkpointcheckpointCallStackWithcheckpointCallStackcheckpointManyannotatedExceptionCallStackaddCallStackToException$fExceptionAnnotatedException$fApplicativeAnnotatedException$fShowAnnotatedException$fFunctorAnnotatedException$fFoldableAnnotatedException$fTraversableAnnotatedExceptionGHC.Stack.Types CallStackghc-prim GHC.ClassesEqData.Typeable.InternalTypeableGHC.ShowShowshow Data.Typeablecastcontainers-0.6.7Data.Set.InternalSet GHC.MaybeNothing Data.ProxyKProxyProxy asProxyTypeOfannotate.safe-exceptions-0.1.7.4-24KZT8FH3V23Q1o5W8bHMFControl.Exception.SafemkAnnotatedHandlersflatten HasCallStackordNubversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDirgetDataFileName getSysconfDir