Sample definitions for derived forms

This appendix contains sample definitions for some of the keywords described in this report in terms of simpler forms:

cond

The cond keyword (section 11.4.5) could be defined in terms of if, let and begin using syntax-rules as follows:

(define-syntax cond

  (syntax-rules (else =>)

    ((cond (else result1 result2 ...))

     (begin result1 result2 ...))

    ((cond (test => result))

     (let ((temp test))

       (if temp (result temp))))

    ((cond (test => result) clause1 clause2 ...)

     (let ((temp test))

       (if temp

           (result temp)

           (cond clause1 clause2 ...))))

    ((cond (test)) test)

    ((cond (test) clause1 clause2 ...)

     (let ((temp test))

       (if temp

           temp

           (cond clause1 clause2 ...))))

    ((cond (test result1 result2 ...))

     (if test (begin result1 result2 ...)))

    ((cond (test result1 result2 ...)

           clause1 clause2 ...)

     (if test

         (begin result1 result2 ...)

         (cond clause1 clause2 ...)))))

case

The case keyword (section 11.4.5) could be defined in terms of let, cond, and memv (see library chapter on “List utilities”) using syntax-rules as follows:

(define-syntax case

  (syntax-rules (else)

    ((case expr0

       ((key ...) res1 res2 ...)

       ...

       (else else-res1 else-res2 ...))

     (let ((tmp expr0))

       (cond

         ((memv tmp '(key ...)) res1 res2 ...)

         ...

         (else else-res1 else-res2 ...))))

    ((case expr0

       ((keya ...) res1a res2a ...)

       ((keyb ...) res1b res2b ...)

       ...)

     (let ((tmp expr0))

       (cond

         ((memv tmp '(keya ...)) res1a res2a ...)

         ((memv tmp '(keyb ...)) res1b res2b ...)

         ...)))))

let*

The let* keyword (section 11.4.6) could be defined in terms of let using syntax-rules as follows:

(define-syntax let*

  (syntax-rules ()

    ((let* () body1 body2 ...)

     (let () body1 body2 ...))

    ((let* ((name1 expr1) (name2 expr2) ...)

       body1 body2 ...)

     (let ((name1 expr1))

       (let* ((name2 expr2) ...)

         body1 body2 ...)))))

letrec

The letrec keyword (section 11.4.6) could be defined approximately in terms of let and set! using syntax-rules, using a helper to generate the temporary variables needed to hold the values before the assignments are made, as follows:

(define-syntax letrec

  (syntax-rules ()

    ((letrec () body1 body2 ...)

     (let () body1 body2 ...))

    ((letrec ((var init) ...) body1 body2 ...)

     (letrec-helper

       (var ...)

       ()

       ((var init) ...)

       body1 body2 ...))))

(define-syntax letrec-helper

  (syntax-rules ()

    ((letrec-helper

       ()

       (temp ...)

       ((var init) ...)

       body1 body2 ...)

     (let ((var <undefined>) ...)

       (let ((temp init) ...)

         (set! var temp)

         ...)

       (let () body1 body2 ...)))

    ((letrec-helper

       (x y ...)

       (temp ...)

       ((var init) ...)

       body1 body2 ...)

     (letrec-helper

       (y ...)

       (newtemp temp ...)

       ((var init) ...)

       body1 body2 ...))))

The syntax <undefined> represents an expression that returns something that, when stored in a location, causes an exception with condition type &assertion to be raised if an attempt to read from or write to the location occurs before the assignments generated by the letrec transformation take place. (No such expression is defined in Scheme.)

A simpler definition using syntax-case and generate-temporaries is given in library chapter on “syntax-case”.

letrec*

The letrec* keyword could be defined approximately in terms of let and set! using syntax-rules as follows:

(define-syntax letrec*

  (syntax-rules ()

    ((letrec* ((var1 init1) ...) body1 body2 ...)

     (let ((var1 <undefined>) ...)

       (set! var1 init1)

       ...

       (let () body1 body2 ...)))))

The syntax <undefined> is as in the definition of letrec above.

let-values

The following definition of let-values (section 11.4.6) using syntax-rules employs a pair of helpers to create temporary names for the formals.

(define-syntax let-values

  (syntax-rules ()

    ((let-values (binding ...) body1 body2 ...)

     (let-values-helper1

       ()

       (binding ...)

       body1 body2 ...))))

(define-syntax let-values-helper1

  ;; map over the bindings

  (syntax-rules ()

    ((let-values

       ((id temp) ...)

       ()

       body1 body2 ...)

     (let ((id temp) ...) body1 body2 ...))

    ((let-values

       assocs

       ((formals1 expr1) (formals2 expr2) ...)

       body1 body2 ...)

     (let-values-helper2

       formals1

       ()

       expr1

       assocs

       ((formals2 expr2) ...)

       body1 body2 ...))))

(define-syntax let-values-helper2

  ;; create temporaries for the formals

  (syntax-rules ()

    ((let-values-helper2

       ()

       temp-formals

       expr1

       assocs

       bindings

       body1 body2 ...)

     (call-with-values

       (lambda () expr1)

       (lambda temp-formals

         (let-values-helper1

           assocs

           bindings

           body1 body2 ...))))

    ((let-values-helper2

       (first . rest)

       (temp ...)

       expr1

       (assoc ...)

       bindings

       body1 body2 ...)

     (let-values-helper2

       rest

       (temp ... newtemp)

       expr1

       (assoc ... (first newtemp))

       bindings

       body1 body2 ...))

    ((let-values-helper2

       rest-formal

       (temp ...)

       expr1

       (assoc ...)

       bindings

       body1 body2 ...)

     (call-with-values

       (lambda () expr1)

       (lambda (temp ... . newtemp)

         (let-values-helper1

           (assoc ... (rest-formal newtemp))

           bindings

           body1 body2 ...))))))

let*-values

The following macro defines let*-values in terms of let and let-values using syntax-rules:

(define-syntax let*-values

  (syntax-rules ()

    ((let*-values () body1 body2 ...)

     (let () body1 body2 ...))

    ((let*-values (binding1 binding2 ...)

       body1 body2 ...)

     (let-values (binding1)

       (let*-values (binding2 ...)

         body1 body2 ...)))))

let

The let keyword could be defined in terms of lambda and letrec using syntax-rules as follows:

(define-syntax let

  (syntax-rules ()

    ((let ((name val) ...) body1 body2 ...)

     ((lambda (name ...) body1 body2 ...)

      val ...))

    ((let tag ((name val) ...) body1 body2 ...)

     ((letrec ((tag (lambda (name ...)

                      body1 body2 ...)))

        tag)

      val ...))))