Hoogle Search

Within LTS Haskell 23.24 (ghc-9.8.4)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. class (Typeable e, Show e) => Exception e

   monadology	Control.Monad.Ology.General.Throw

   Any type that you wish to throw or catch as an exception must be an instance of the Exception class. The simplest case is a new exception type directly below the root:

   data MyException = ThisException | ThatException
   deriving Show
   
   instance Exception MyException
   

   The default method definitions in the Exception class do what we need in this case. You can now throw and catch ThisException and ThatException as exceptions:

   *Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
   Caught ThisException
   

   In more complicated examples, you may wish to define a whole hierarchy of exceptions:

   ---------------------------------------------------------------------
   -- Make the root exception type for all the exceptions in a compiler
   
   data SomeCompilerException = forall e . Exception e => SomeCompilerException e
   
   instance Show SomeCompilerException where
   show (SomeCompilerException e) = show e
   
   instance Exception SomeCompilerException
   
   compilerExceptionToException :: Exception e => e -> SomeException
   compilerExceptionToException = toException . SomeCompilerException
   
   compilerExceptionFromException :: Exception e => SomeException -> Maybe e
   compilerExceptionFromException x = do
   SomeCompilerException a <- fromException x
   cast a
   
   ---------------------------------------------------------------------
   -- Make a subhierarchy for exceptions in the frontend of the compiler
   
   data SomeFrontendException = forall e . Exception e => SomeFrontendException e
   
   instance Show SomeFrontendException where
   show (SomeFrontendException e) = show e
   
   instance Exception SomeFrontendException where
   toException = compilerExceptionToException
   fromException = compilerExceptionFromException
   
   frontendExceptionToException :: Exception e => e -> SomeException
   frontendExceptionToException = toException . SomeFrontendException
   
   frontendExceptionFromException :: Exception e => SomeException -> Maybe e
   frontendExceptionFromException x = do
   SomeFrontendException a <- fromException x
   cast a
   
   ---------------------------------------------------------------------
   -- Make an exception type for a particular frontend compiler exception
   
   data MismatchedParentheses = MismatchedParentheses
   deriving Show
   
   instance Exception MismatchedParentheses where
   toException   = frontendExceptionToException
   fromException = frontendExceptionFromException
   

   We can now catch a MismatchedParentheses exception as MismatchedParentheses, SomeFrontendException or SomeCompilerException, but not other types, e.g. IOException:

   *Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
   Caught MismatchedParentheses
   *Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
   Caught MismatchedParentheses
   *Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
   Caught MismatchedParentheses
   *Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: IOException))
   *** Exception: MismatchedParentheses
   

2. module Web.Simple.Controller.Exception

   No documentation available.

3. module Streamly.Internal.Control.Exception

   Additional Control.Exception utilities.

4. exception :: Exception a => Prism' SomeException a

   lens	Control.Exception.Lens

   Traverse the strongly typed Exception contained in SomeException where the type of your function matches the desired Exception.

   exception :: (Applicative f, Exception a)
   => (a -> f a) -> SomeException -> f SomeException
   

5. exception :: Exceptional e a -> Maybe e

   explicit-exception	Control.Monad.Exception.Asynchronous.Lazy

   No documentation available.

6. exception :: Exceptional e a -> Maybe e

   explicit-exception	Control.Monad.Exception.Asynchronous.Strict

   No documentation available.

7. exception :: AnnotatedException exception -> exception

   annotated-exception	Control.Exception.Annotated

   No documentation available.

8. exception :: AnnotatedException exception -> exception

   annotated-exception	Control.Exception.Annotated.UnliftIO

   No documentation available.

9. data ExceptionInLinkedThread

   async	Control.Concurrent.Async

   No documentation available.

10. ExceptionInLinkedThread :: Async a -> SomeException -> ExceptionInLinkedThread

    async	Control.Concurrent.Async

    No documentation available.

Page 3 of many | Previous | Next