Awesome
purescript-checked-exceptions
Extensible checked exceptions using polymorphic variants
The Expression Exception Problem
Given some function for making HTTP requests which propagates an HttpError
for failures cases:
get
∷ ∀ m
. MonadHttp m
⇒ String
→ ExceptT HttpError m String
And another for writing files which propagates an FsError
for failures cases:
write
∷ ∀ m
. MonadFs m
⇒ Path
→ String
→ ExceptT FsError m Unit
What happens when we combine them?
getPureScript
∷ ∀ m
. MonadHttp m
⇒ MonadFs m
⇒ ExceptT _ m Unit
getPureScript =
get "http://purescript.org" >>= write "~/purescript.html"
Could not match type
FsError
with type
HttpError
Before we can get anywhere, we must unify the error types.
getPureScript
∷ ∀ m
. MonadHttp m
⇒ MonadFs m
⇒ ExceptT (Either HttpError FsError) m Unit
getPureScript = do
resp <- withExceptT Left (get "http://purescript.org")
rethrow Right (write "~/purescript.html" resp)
This gets very tedious, very quickly, because every new exception type we introduce breaks code we've already written.
Polymorphic Variants to the Rescue
Variant
lets us define
structural sum types. Row types in a Record
point to fields, while row
types in a Variant
point to tags. That means we only have to care about
the cases we want to use, and they work together regardless of which module
defined them.
We'll start with a little bit of sugar (this helps the types go down easy):
type RowApply (f :: # Type -> # Type) (a :: # Type) = f a
infixr 0 type RowApply as +
We'll define our HttpError
variants with rows instead of the usual data
declaration:
type HttpServerError r = (httpServerError ∷ String | r)
type HttpNotFound r = (httpNotFound ∷ Unit | r)
type HttpOther r = (httpOther ∷ { status ∷ Int, body ∷ String } | r)
And add constructors which lift them into Variant
:
httpServerError ∷ ∀ r. String → Variant (HttpServerError + r)
httpServerError = inj (SProxy ∷ SProxy "httpServerError")
httpNotFound ∷ ∀ r. Variant (HttpNotFound + r)
httpNotFound = inj (SProxy ∷ SProxy "httpNotFound") unit
httpOther ∷ ∀ r. Int → String → Variant (HttpOther + r)
httpOther status body = inj (SProxy ∷ SProxy "httpOther") { status, body }
We can then define a helpful alias for all of our HTTP exceptions:
type HttpError r =
( HttpServerError
+ HttpNotFound
+ HttpOther
+ r
)
Now in another module we might do the same for FS exceptions:
type FsPermissionDenied r = (fsPermissionDenied ∷ Unit | r)
type FsFileNotFound r = (fsFileNotFound ∷ Path | r)
fsPermissionDenied ∷ ∀ r. Variant (FsPermissionDenied + r)
fsPermissionDenied = inj (SProxy ∷ SProxy "fsPermissionDenied") unit
fsFileNotFound ∷ ∀ r. Path → Variant (FsFileNotFound + r)
fsFileNotFound = inj (SProxy ∷ SProxy "fsFileNotFound")
type FsError r =
( FsPermissionDenied
+ FsFileNotFound
+ r
)
Let's go back to our original example, but instead of ExceptT
we will
substitute ExceptV
:
type ExceptV exc = ExceptT (Variant exc)
get
∷ ∀ r m
. MonadHttp m
⇒ String
→ ExceptV (HttpError + r) m String
write
∷ ∀ r m
. MonadFs m
⇒ Path
→ String
→ ExceptV (FsError + r) m Unit
When we go to combine them, it just works:
getPureScript
∷ ∀ r m
. MonadHttp m
⇒ MonadFs m
⇒ ExceptV (HttpError + FsError + r) m Unit
getPureScript =
get "http://purescript.org" >>= write "~/purescript.html"
Additionally, these types are completely inferrable:
Wildcard type definition has the inferred type
( httpServerError :: String
, httpNotFound :: Unit
, httpOther :: { status :: Int
, body :: String
}
, fsFileNotFound :: String
, fsPermissionDenied :: Unit
| t0
)
Handling Errors
This library exports the handleError
function. Given a record of exception
handlers, it will catch and route the corresponding exceptions, eliminating
them from the type.
getPureScript # handleError
{ httpServerError: \error -> log $ "Server error:" <> error
, httpNotFound: \_ -> log "Not found"
}
Wildcard type definition has the inferred type
( fsFileNotFound :: String
, fsPermissionDenied :: Unit
, httpOther :: { status :: Int
, body :: String
}
| t0
)
This lets us prove that all exceptions have been handled, which means
we can safely remove the ExceptV
wrapper using the safe
combinator.
getPureScriptSafe
:: forall m
. MonadHttp m
=> MonadFs m
=> MonadLog m
-> m Unit
getPureScriptSafe =
safe $ getPureScript # handleError
{ httpServerError: ...
, httpNotFound: ...
, httpOther: ...
, fsFileNotFound: ...
, fsPermissionDenied ...
}