Servant.Exception.Server

HasServer instances for the Throws api combinator.

Documentation

data Throws e

Declare that an API might throw errors of given type e.

Instances

HasServer ((Throws e :> api1) :<|> (Throws e :> api2)) context => HasServer (Throws e :> (api1 :<|> api2) :: Type) context

Transitive application of Throws on (:<|>).

Defined in Servant.Exception.Server

Associated Types

type ServerT (Throws e :> (api1 :<|> api2)) m

Methods

route :: Proxy (Throws e :> (api1 :<|> api2)) -> Context context -> Delayed env (Server (Throws e :> (api1 :<|> api2))) -> Router env

hoistServerWithContext :: Proxy (Throws e :> (api1 :<|> api2)) -> Proxy context -> (forall x. m x -> n x) -> ServerT (Throws e :> (api1 :<|> api2)) m -> ServerT (Throws e :> (api1 :<|> api2)) n

HasServer (api :> (Throws e :> upstream)) context => HasServer (Throws e :> (api :> upstream) :: Type) context

Push Throws further "upstream".

Defined in Servant.Exception.Server

Associated Types

type ServerT (Throws e :> (api :> upstream)) m

Methods

route :: Proxy (Throws e :> (api :> upstream)) -> Context context -> Delayed env (Server (Throws e :> (api :> upstream))) -> Router env

hoistServerWithContext :: Proxy (Throws e :> (api :> upstream)) -> Proxy context -> (forall x. m x -> n x) -> ServerT (Throws e :> (api :> upstream)) m -> ServerT (Throws e :> (api :> upstream)) n

(Exception e, ToServantErr e, AllMimeRender ct e, HasServer (Verb mt st ct a) context) => HasServer (Throws e :> Verb mt st ct a :: Type) context

Main HasServer instance for 'Throws e'. Catches exceptions of type e in the upstream server and encodes them using ToServantErr and MimeRender to a response with appropriate content-type (uses hAccept header) and body.

Defined in Servant.Exception.Server

Associated Types

type ServerT (Throws e :> Verb mt st ct a) m

Methods

route :: Proxy (Throws e :> Verb mt st ct a) -> Context context -> Delayed env (Server (Throws e :> Verb mt st ct a)) -> Router env

hoistServerWithContext :: Proxy (Throws e :> Verb mt st ct a) -> Proxy context -> (forall x. m x -> n x) -> ServerT (Throws e :> Verb mt st ct a) m -> ServerT (Throws e :> Verb mt st ct a) n

type ServerT (Throws e :> (api1 :<|> api2) :: Type) m

Defined in Servant.Exception.Server

type ServerT (Throws e :> (api1 :<|> api2) :: Type) m = ServerT ((Throws e :> api1) :<|> (Throws e :> api2)) m

type ServerT (Throws e :> (api :> upstream) :: Type) m

Defined in Servant.Exception.Server

type ServerT (Throws e :> (api :> upstream) :: Type) m = ServerT (api :> (Throws e :> upstream)) m

type ServerT (Throws e :> Verb mt st ct a :: Type) m

Defined in Servant.Exception.Server

type ServerT (Throws e :> Verb mt st ct a :: Type) m = ServerT (Verb mt st ct a) m

class (Typeable e, Show e) => ToServantErr e where

Type class to convert an e to servant's error types, e.g. ServerError on the server side. Thus, servers use methods of this class, along with Typeable and Show allow convenient definition of how error responses should look like.

Minimal complete definition

status

Methods

status :: e -> Status

HTTP status code to return

message :: e -> Text

A human-readable message to include. Default implementation uses Show.

headers :: e -> [Header]

Additional headers to include in the response. Content-type headers are created by default.

Instances

ToServantErr ServantException

Defined in Servant.Exception

Methods

status :: ServantException -> Status

message :: ServantException -> Text

headers :: ServantException -> [Header]

data ServantException

A root exception type (see Exception) to provide a common rendering format via MimeRender for builtin content types JSON and PlainText.

Instances

Show ServantException

Defined in Servant.Exception

Methods

showsPrec :: Int -> ServantException -> ShowS

show :: ServantException -> String

showList :: [ServantException] -> ShowS

Exception ServantException

Defined in Servant.Exception

Methods

toException :: ServantException -> SomeException

fromException :: SomeException -> Maybe ServantException

displayException :: ServantException -> String

ToServantErr ServantException

Defined in Servant.Exception

Methods

status :: ServantException -> Status

message :: ServantException -> Text

headers :: ServantException -> [Header]

MimeRender JSON ServantException

Defined in Servant.Exception

Methods

mimeRender :: Proxy JSON -> ServantException -> ByteString

MimeRender PlainText ServantException

Defined in Servant.Exception

Methods

mimeRender :: Proxy PlainText -> ServantException -> ByteString

toServantException :: (Exception e, ToJSON e, ToServantErr e) => e -> SomeException

fromServantException :: Exception e => SomeException -> Maybe e

class (Typeable e, Show e) => Exception e where

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

Minimal complete definition

Nothing

Methods

toException :: e -> SomeException

fromException :: SomeException -> Maybe e

displayException :: e -> String

Render this exception value in a human-friendly manner.

Default implementation: show.

Since: base-4.8.0.0

Instances

Exception Void

Since: base-4.8.0.0

Defined in Data.Void

Methods

toException :: Void -> SomeException

fromException :: SomeException -> Maybe Void

displayException :: Void -> String

Exception BlockedIndefinitelyOnMVar

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: BlockedIndefinitelyOnMVar -> SomeException

fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar

displayException :: BlockedIndefinitelyOnMVar -> String

Exception BlockedIndefinitelyOnSTM

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: BlockedIndefinitelyOnSTM -> SomeException

fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM

displayException :: BlockedIndefinitelyOnSTM -> String

Exception Deadlock

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: Deadlock -> SomeException

fromException :: SomeException -> Maybe Deadlock

displayException :: Deadlock -> String

Exception AllocationLimitExceeded

Since: base-4.8.0.0

Defined in GHC.IO.Exception

Methods

toException :: AllocationLimitExceeded -> SomeException

fromException :: SomeException -> Maybe AllocationLimitExceeded

displayException :: AllocationLimitExceeded -> String

Exception CompactionFailed

Since: base-4.10.0.0

Defined in GHC.IO.Exception

Methods

toException :: CompactionFailed -> SomeException

fromException :: SomeException -> Maybe CompactionFailed

displayException :: CompactionFailed -> String

Exception AssertionFailed

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: AssertionFailed -> SomeException

fromException :: SomeException -> Maybe AssertionFailed

displayException :: AssertionFailed -> String

Exception SomeAsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

toException :: SomeAsyncException -> SomeException

fromException :: SomeException -> Maybe SomeAsyncException

displayException :: SomeAsyncException -> String

Exception AsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

toException :: AsyncException -> SomeException

fromException :: SomeException -> Maybe AsyncException

displayException :: AsyncException -> String

Exception ArrayException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: ArrayException -> SomeException

fromException :: SomeException -> Maybe ArrayException

displayException :: ArrayException -> String

Exception FixIOException

Since: base-4.11.0.0

Defined in GHC.IO.Exception

Methods

toException :: FixIOException -> SomeException

fromException :: SomeException -> Maybe FixIOException

displayException :: FixIOException -> String

Exception ExitCode

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: ExitCode -> SomeException

fromException :: SomeException -> Maybe ExitCode

displayException :: ExitCode -> String

Exception IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: IOException -> SomeException

fromException :: SomeException -> Maybe IOException

displayException :: IOException -> String

Exception ArithException

Since: base-4.0.0.0

Defined in GHC.Exception.Type

Methods

toException :: ArithException -> SomeException

fromException :: SomeException -> Maybe ArithException

displayException :: ArithException -> String

Exception SomeException

Since: base-3.0

Defined in GHC.Exception.Type

Methods

toException :: SomeException -> SomeException

fromException :: SomeException -> Maybe SomeException

displayException :: SomeException -> String

Exception ASCII7_Invalid

Defined in Basement.String.Encoding.ASCII7

Methods

toException :: ASCII7_Invalid -> SomeException

fromException :: SomeException -> Maybe ASCII7_Invalid

displayException :: ASCII7_Invalid -> String

Exception ISO_8859_1_Invalid

Defined in Basement.String.Encoding.ISO_8859_1

Methods

toException :: ISO_8859_1_Invalid -> SomeException

fromException :: SomeException -> Maybe ISO_8859_1_Invalid

displayException :: ISO_8859_1_Invalid -> String

Exception UTF16_Invalid

Defined in Basement.String.Encoding.UTF16

Methods

toException :: UTF16_Invalid -> SomeException

fromException :: SomeException -> Maybe UTF16_Invalid

displayException :: UTF16_Invalid -> String

Exception UTF32_Invalid

Defined in Basement.String.Encoding.UTF32

Methods

toException :: UTF32_Invalid -> SomeException

fromException :: SomeException -> Maybe UTF32_Invalid

displayException :: UTF32_Invalid -> String

Exception InvalidAccess

Defined in Control.Monad.Trans.Resource.Internal

Methods

toException :: InvalidAccess -> SomeException

fromException :: SomeException -> Maybe InvalidAccess

displayException :: InvalidAccess -> String

Exception ResourceCleanupException

Defined in Control.Monad.Trans.Resource.Internal

Methods

toException :: ResourceCleanupException -> SomeException

fromException :: SomeException -> Maybe ResourceCleanupException

displayException :: ResourceCleanupException -> String

Exception ServantException

Defined in Servant.Exception

Methods

toException :: ServantException -> SomeException

fromException :: SomeException -> Maybe ServantException

displayException :: ServantException -> String

Exception ServerError

Defined in Servant.Server.Internal.ServerError

Methods

toException :: ServerError -> SomeException

fromException :: SomeException -> Maybe ServerError

displayException :: ServerError -> String

mapException :: (Exception e1, Exception e2, MonadCatch m) => (e1 -> e2) -> m a -> m a

Catch and rethrow using mapping function f.

Orphan instances

HasServer ((Throws e :> api1) :<|> (Throws e :> api2)) context => HasServer (Throws e :> (api1 :<|> api2) :: Type) context

Transitive application of Throws on (:<|>).

Associated Types

type ServerT (Throws e :> (api1 :<|> api2)) m

Methods

route :: Proxy (Throws e :> (api1 :<|> api2)) -> Context context -> Delayed env (Server (Throws e :> (api1 :<|> api2))) -> Router env

hoistServerWithContext :: Proxy (Throws e :> (api1 :<|> api2)) -> Proxy context -> (forall x. m x -> n x) -> ServerT (Throws e :> (api1 :<|> api2)) m -> ServerT (Throws e :> (api1 :<|> api2)) n

HasServer (api :> (Throws e :> upstream)) context => HasServer (Throws e :> (api :> upstream) :: Type) context

Push Throws further "upstream".

Associated Types

type ServerT (Throws e :> (api :> upstream)) m

Methods

route :: Proxy (Throws e :> (api :> upstream)) -> Context context -> Delayed env (Server (Throws e :> (api :> upstream))) -> Router env

hoistServerWithContext :: Proxy (Throws e :> (api :> upstream)) -> Proxy context -> (forall x. m x -> n x) -> ServerT (Throws e :> (api :> upstream)) m -> ServerT (Throws e :> (api :> upstream)) n

(Exception e, ToServantErr e, AllMimeRender ct e, HasServer (Verb mt st ct a) context) => HasServer (Throws e :> Verb mt st ct a :: Type) context

Main HasServer instance for 'Throws e'. Catches exceptions of type e in the upstream server and encodes them using ToServantErr and MimeRender to a response with appropriate content-type (uses hAccept header) and body.

Associated Types

type ServerT (Throws e :> Verb mt st ct a) m

Methods

route :: Proxy (Throws e :> Verb mt st ct a) -> Context context -> Delayed env (Server (Throws e :> Verb mt st ct a)) -> Router env

hoistServerWithContext :: Proxy (Throws e :> Verb mt st ct a) -> Proxy context -> (forall x. m x -> n x) -> ServerT (Throws e :> Verb mt st ct a) m -> ServerT (Throws e :> Verb mt st ct a) n