Using `with-handlers` to catch exceptions.

gistfile1.rkt

#lang racket

;; The way to catch exceptions is `with-handlers`.
;; See http://docs.racket-lang.org/reference/exns.html
;;
;; You specify the type of exception, and a function to handle it. The
;; exception object is passed to the function.
;;
;; For exmaple, we'll catch the "generic" `exn:fail?` with a function
;; that we define in-place using `lambda`:
(with-handlers ([exn:fail? (lambda (exn)
                             (displayln (exn-message exn))
                             42)])
  (error 'foo "bar")
  1)
;; =>
;; foo: bar
;; 42

;; Notice that the result of the entire `with-handlers` expression is
;; 42, not 1.

;; There are a variety of exception struct types, nearly all derived
;; from `exn:fail?`.
;;
;; `with-handlers` can take a list of more than one exception type
;; (and its handler function). They are matched in order:

(with-handlers ([exn:fail:user? (lambda (exn)
                                  (display "User error: ")
                                  (displayln (exn-message exn))
                                  99)]
                [exn:fail? (lambda (exn)
                             (display "Generic exception: ")
                             (displayln (exn-message exn))
                             42)])
  (raise-user-error 'foo "bar")
  1)

;; =>
;; User error: foo: bar
;; 99