Question

I have just finished up the compilers course at IU and am trying to add a few more forms to my little “scheme”. We added several forms into our language via syntactic sugar where a full scheme would typically use macro-expansion (and and or were the main ones). The problem I’ve come across is desugaring a cond statement.

As a note: I am going back and forth between Chez and Petite Chez as I work.

I am trying to handle all of the cond clause forms. When handling the (test => expr) form, I seem to be running into problems working with the =>. I can’t seem to do anything to it without getting a misplaced aux keyword error or having the clause fall through to the next line in my match statement.

Any ideas on how I can detect this keyword?

Answer 1

I wrote my own Scheme metacircular interpreter some time ago, with support for the => syntax in the cond special form. In essence, this is what I had to do:

(define (expand-actions clause)
  (let ((exp (sequence->exp (cond-actions clause))))
    (if (cond-has-then? clause)
        (make-application exp
                          (if (cond-else-clause? clause)
                              #t
                              (list (cond-predicate clause))))
        exp)))

When iterating over all the clauses (pairs of predicates and actions) of a cond expression, I expand each action and ask if the => token is present in the clause (using cond-has-then?). If => was found, I apply the action part of the clause to the predicate.

Here’s the complete piece of code in charge of evaluating cond expressions in my interpreter, the main procedure (the one called from eval) is cond->if, which transforms a cond expression into a series of nested if expressions, and also deals with the => syntax; I hope this is helpful for you:

(define (cond->if exp)
  (expand-clauses (cond-clauses exp)))

(define cond-clauses cdr)

(define (cond-has-then? clause)
  (eq? (cadr clause) '=>))

(define cond-predicate car)

(define (cond-actions clause)
  (if (cond-has-then? clause)
      (cddr clause)
      (cdr clause)))

(define (cond-else-clause? clause)
  (eq? (cond-predicate clause) 'else))

(define (expand-clauses clauses)
  (if (null? clauses)
      (void)
      (let ((first (car clauses))
            (rest  (cdr clauses)))
        (if (cond-else-clause? first)
            (if (null? rest)
                (expand-actions first)
                (error "ELSE clause isn't last -- COND->IF" clauses))
            (make-if (cond-predicate first)
                     (expand-actions first)
                     (expand-clauses rest))))))

(define (expand-actions clause)
  (let ((exp (sequence->exp (cond-actions clause))))
    (if (cond-has-then? clause)
        (make-application exp
                          (if (cond-else-clause? clause)
                              #t
                              (list (cond-predicate clause))))
        exp)))

(define (make-if predicate consequent alternative)
  (list 'if predicate consequent alternative))

(define (sequence->exp seq)
  (cond ((null? seq) '())
        ((last-exp? seq) (first-exp seq))
        (else (make-begin seq))))

(define (last-exp? seq)
  (null? (cdr seq)))

(define first-exp car)

(define (make-application proc . args)
  (cond ((null? args) (list proc))
        ((list? (car args)) (cons proc (car args)))
    (else (cons proc args))))

(define (make-begin seq)
  (cons 'begin seq))