# Title

SRFI 23: Error reporting mechanism

# Author

Stephan Houben

# Status

This SRFI is currently in ``final'' status. To see an explanation of each status that a SRFI can hold, see here. You can access the discussion via the archive of the mailing list.

- Draft: 2001/03/09-2001/06/09
- Revised: 2001/03/22
- Revised: 2001/04/26

# Abstract

A mechanism is proposed to allow Scheme code to report errors and abort execution. The proposed mechanism is already implemented in several Scheme systems and can be implemented, albeit imperfectly, in any R5RS conforming Scheme.

# Rationale

R5RS Scheme requires certain operations to signal an error when they fail. "Signalling an error" means that implementations must detect and report the error. Moreover, R5RS encourages, but not requires, implementations to signal an error in many more circumstances.

However, there is no direct way for the Scheme application programmer to report an error that occured in his or her own application. This means that Scheme procedures created by applications or libraries are in this respect not on equal footing with procedures provided by the Scheme system.

Many Scheme systems already provide a mechanism that allows application code to report an error. At least the following implementations support such a mechanism: Bigloo, Guile, MIT Scheme, PLT Scheme, RScheme, Scsh, SCM, all implementations supported by SLIB. Of these implementations, the following have an error mechanism compatible with this SRFI: Guile, MIT Scheme, PLT Scheme, RScheme, Scsh. The implementation in SLIB has a different name than the one proposed in this SRFI.

To summarise, many implementations already have the error reporting mechanism described in this SRFI and others are easily made compatible with this SRFI. This shows that the proposed mechanism is considered useful and that it is easy to implement in most major implementations.

# Specification

The following procedure should be provided:

`(error` <reason>`[<arg1> [<arg2> ...]])`

The argument <reason> should be a string. The procedure `error` will signal an error, as described in R5RS, and it will report the message <reason> and the objects <arg1>, <arg2>, .... What exactly constitutes "signalling" and "reporting" is not prescribed, because of the large variation in Scheme systems. So it is left to the implementor to do something reasonable. To that end, a few examples of possible behaviour are given.

1. Display <reason> and <arg1>... on the screen and terminate the Scheme program. (This might be suitable for a Scheme system implemented as a batch compiler.)
2. Display <reason> and <arg1>... on the screen and go back to the read-evaluate-print loop. (This might be suitable for an interactive implementation).
3. In the case of a multi-threaded system: terminate the current thread, but do not terminate the other threads. Possibly make the arguments to `error` available to other threads in some way. See the `thread-join!` mechanism in SRFI-18 on how this could be done.
4. Package <reason> and <arg1>... up into an error object and pass this error object to an exception handler. The default exception handler then might do something as described in points 1 to 3.
5. In the case of a Scheme system that runs completely unattended and that has no way to notify a human, the only reasonable course of action might be to do nothing at all. However, this should be considered a last resort. Clearly, if all implementors would choose this strategy, this SRFI would not be very useful.

An implementation might report more information than just <reason> and <arg1>... . For instance, it might report the procedure name in which the error occured or even print a stack trace. However, this will require additional support in the Scheme implementation.

# Why `error` is a procedure

It is conceivable to allow `error` to be a special form, such as a macro, rather than a procedure. This might make providing information such as the source code location easier. This possibility has been considered, but rejected, for two reasons.

1. Since `error` accepts a variable number of arguments, it could occasionally be useful to use `apply` to call `error`. However, this is not possible if `error` was allowed to be a special form.
2. Since `error` is currently a procedure in all Scheme implementations mentioned above, it doesn't seem all that worthwhile to allow it to be a special form.

# Implementation

An implementation that works in almost any R5RS Scheme is the following:

      (define (error reason . args)
          (display "Error: ")
          (display reason)
          (for-each (lambda (arg)
                      (display " ")
    		  (write arg))
    		args)
          (newline)
          (scheme-report-environment -1))  ;; we hope that this will signal an error

This implementation has a flaw, namely, in many implementations this will actually print 2 messages.

1. The message `message`, followed by `objs`, and
2. A message about `scheme-report-environment` getting an invalid argument.

This might be confusing to the user.

The SLIB procedure `slib:error` works like the `error` procedure described in this document. Thus, when SLIB is loaded, `error` can be defined as:

      (define error slib:error)

If SRFI 18 is supported, it is allowed (but not required) to implement `error` in terms of the exception mechanism of SRFI 18.

      (define (error reason . args)
        (raise (make-error-exception reason args)))

Here, `make-error-exception` is implementation dependent.

# Copyright

Copyright (C) Stephan Houben (2001). All Rights Reserved.

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Last modified: Mon Feb 4 14:46:29 MET 2002