This section describes Scheme’s exception-handling and exception-raising
procedures. For the concept of Scheme exceptions, see Error situations and unspecified behavior. See Exception handling for the
guard syntax.
Exception handlers are one-argument procedures that determine the action the program takes when an exceptional situation is signaled. The system implicitly maintains a current exception handler in the dynamic environment.
The program raises an exception by invoking the current exception handler, passing it an object encapsulating information about the exception. Any procedure accepting one argument can serve as an exception handler and any object can be used to represent an exception.
(with-exception-handler handler thunk) ¶It is an error if handler does not accept one argument. It is also an error if thunk does not accept zero arguments.
The with-exception-handler procedure returns the results of
invoking thunk. Handler is installed as the current
exception handler in the dynamic environment used for the invocation of
thunk.
(call-with-current-continuation (lambda (k) (with-exception-handler (lambda (x) (display "condition: ") (write x) (newline) (k 'exception)) (lambda () (+ 1 (raise 'an-error)))))) ⇒ exception and prints condition: an-error (with-exception-handler (lambda (x) (display "something went wrong\n")) (lambda () (+ 1 (raise 'an-error)))) prints something went wrong
After printing, the second example then raises another exception.
(raise obj) ¶Raises an exception by invoking the current exception handler on
obj. The handler is called with the same dynamic environment as
that of the call to raise, except that the current exception
handler is the one that was in place when the handler being called was
installed. If the handler returns, a secondary exception is raised in
the same dynamic environment as the handler. The relationship between
obj and the object raised by the secondary exception is
unspecified.
(raise-continuable obj) ¶Raises an exception by invoking the current exception handler on
obj. The handler is called with the same dynamic environment as
the call to raise-continuable, except that: (1) the current
exception handler is the one that was in place when the handler being
called was installed, and (2) if the handler being called returns, then
it will again become the current exception handler. If the handler
returns, the values it returns become the values returned by the call to
raise-continuable.
(with-exception-handler (lambda (con) (cond ((string? con) (display con)) (else (display "a warning has been issued"))) 42) (lambda () (+ (raise-continuable "should be a number") 23))) prints should be a number ⇒ 65
(error message obj …) ¶Message should be a string.
Raises an exception as if by calling raise on a newly allocated
implementation-defined object which encapsulates the information
provided by message, as well as any objs, known as the
irritants. The procedure error-object? must return
#t on such objects.
(define (null-list? l) (cond ((pair? l) #f) ((null? l) #t) (else (error "null-list?: argument out of domain" l))))
(error-object? obj) ¶Returns #t if obj is an object created by error or one
of an implementation-defined set of objects. Otherwise, it returns
#f. The objects used to signal errors, including those which
satisfy the predicates file-error? and read-error?, may or may
not satisfy error-object?.
(error-object-message error-object) ¶Returns the message encapsulated by error-object.
(error-object-irritants error-object) ¶Returns a list of the irritants encapsulated by error-object.