;;;; the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
;;;; Boston, MA 02111-1307 USA
;;;;
+;;;; As a special exception, the Free Software Foundation gives permission
+;;;; for additional uses of the text contained in its release of GUILE.
+;;;;
+;;;; The exception is that, if you link the GUILE library with other files
+;;;; to produce an executable, this does not by itself cause the
+;;;; resulting executable to be covered by the GNU General Public License.
+;;;; Your use of that executable is in no way restricted on account of
+;;;; linking the GUILE library code into it.
+;;;;
+;;;; This exception does not however invalidate any other reasons why
+;;;; the executable file might be covered by the GNU General Public License.
+;;;;
+;;;; This exception applies only to the code released by the
+;;;; Free Software Foundation under the name GUILE. If you copy
+;;;; code from other Free Software Foundation releases into a copy of
+;;;; GUILE, as the General Public License permits, the exception does
+;;;; not apply to the code that you add in this way. To avoid misleading
+;;;; anyone as to the status of such modified files, you must delete
+;;;; this exception notice from them.
+;;;;
+;;;; If you write modifications of your own for GUILE, it is your choice
+;;;; whether to permit this exception to apply to your modifications.
+;;;; If you do not wish that, delete this exception notice.
+;;;;
;;;; Contributed by Maciej Stachowiak <mstachow@alum.mit.edu>
\f
;;; a convenient and attractive syntax.
;;;
;;; exported macros are:
-;;; bound?
;;; let-optional
;;; let-optional*
;;; let-keywords
(define-module (ice-9 optargs))
-;; bound? var
-;; Checks if a variable is bound in the current environment.
-;;
-;; defined? doesn't quite cut it as it stands, since it only
-;; checks bindings in the top-level environment, not those in
-;; local scope only.
-;;
-
-(defmacro-public bound? (var)
- `(catch 'misc-error
- (lambda ()
- ,var
- (not (eq? ,var ,(variable-ref
- (make-undefined-variable)))))
- (lambda args #f)))
-
-
;; let-optional rest-arg (binding ...) . body
;; let-optional* rest-arg (binding ...) . body
;; macros used to bind optional arguments
;;
-;; These two macros give you an optional argument interface that
-;; is very "Schemey" and introduces no fancy syntax. They are
-;; compatible with the scsh macros of the same name, but are slightly
+;; These two macros give you an optional argument interface that is
+;; very "Schemey" and introduces no fancy syntax. They are compatible
+;; with the scsh macros of the same name, but are slightly
;; extended. Each of binding may be of one of the forms <var> or
;; (<var> <default-value>). rest-arg should be the rest-argument of
;; the procedures these are used from. The items in rest-arg are
;; sequentially bound to the variable namess are given. When rest-arg
;; runs out, the remaining vars are bound either to the default values
-;; or left unbound if no default value was specified. rest-arg remains
+;; or to `#f' if no default value was specified. rest-arg remains
;; bound to whatever may have been left of rest-arg.
;;
(let ((bindings (map (lambda (x)
(if (list? x)
x
- (list x (variable-ref
- (make-undefined-variable)))))
+ (list x #f)))
BINDINGS)))
`(,let-type ,(map proc bindings) ,@BODY)))
;; "#&optional" instead of "#:optional"
(read-hash-extend #\& (lambda (c port)
- (display
- "WARNING: `#&' is deprecated, use `#:' instead\n"
- (current-error-port))
+ (issue-deprecation-warning
+ "`#&' is deprecated, use `#:' instead.")
(case (read port)
((optional) #:optional)
((key) #:key)
;; (lambda* (a b #:optional c d . e) '())
;; creates a procedure with fixed arguments a and b, optional arguments c
;; and d, and rest argument e. If the optional arguments are omitted
-;; in a call, the variables for them are unbound in the procedure. This
-;; can be checked with the bound? macro.
+;; in a call, the variables for them are bound to `#f'.
;;
;; lambda* can also take keyword arguments. For example, a procedure
;; defined like this:
`((if (not (null? ,rest-gensym))
(error "Too many arguments.")))
'())
- ,@BODY)))
+ (let ()
+ ,@BODY))))
`(lambda (,@non-optional-args . ,(if rest-arg rest-arg '()))
,@BODY))))))