Bottom line: Your code needs to work, regardless of the abstraction given for mobiles and branches. So, if the underlying implementation were changed to:

(define (make-mobile lb rb) (lambda (msg) (cond ((= msg 0) lb) ((= msg 1) rb)))) (define (left-branch mobile) (mobile 0)) (define (right-branch mobile) (mobile 1)) (define (make-branch l s) (lambda (msg) (cond ((eq? msg 'length) l) ((eq? msg 'structure) s)))) (define (len branch) (branch 'length)) (define (struct branch) (branch 'structure)) (define weight? number?) (define (mobile? structure) (not (weight? structure)))

... your code still needs to work! And it cannot possibly work if you have used list and pair selectors and predicates such as car, cdr, pair?, and list?

Here is a solution; there are other ways to go about this problem
that are equally good. I offer this version as `total-weight`
and `branch-weight` are *mutually recursive* and `balanced?`
can be written without cond or if. I think those features are worth
studying.

(define (total-weight structure) (cond ((weight? structure) structure) (else (+ (branch-weight (left-branch structure)) (branch-weight (right-branch structure)))))) (define (branch-weight branch) (total-weight (struct branch))) (define (torque branch) (* (len branch) (total-weight (struct branch)))) (define (balanced? structure) (or (weight? structure) (and (= (torque (left-branch structure)) (torque (right-branch structure))) (balanced? (struct (left-branch structure))) (balanced? (struct (right-branch structure))))))

One of the most elegant pieces of code I've ever seen...

(define (subsets s) (if (null? s) (list '()) (let ((rest (subsets (cdr s)))) (append rest (map (lambda (set) (cons (car s) set)) rest)))))

I think it is helpful to note the following:

> (subsets '()) (())

is given in the original code. This means that if the call

> (subsets '(A)) (() (A))

is performed, the variable `rest` is going to be `'(())`. The
only way to get the set (A) into the solution is by cons-ing it onto
all of the lists of rest as `(cons 'A '())` is the list of A.

Probably the best way to approach this is to understand that the first input to accumulate is a function that takes two inputs. The first input to that function will be the first element of the sequence (in the form of a list) and the second input will be the rest of the list.

The other thing worth noting is we know what `map`, `append`,
and `length` are supposed to do in Scheme. So, whatever goes into
the given blanks, we can look at what happens with an empty list for the
sequence and a one-element list from the sequence and try to generalize.

Remember also that if e is an element and l is a list, `(cons e l)`
returns a list with e as the car and l as the cdr, which has the effect of
placing e at the beginning of l.

Finally remember that if you need to diagram an N-element list, it will have precisely N pairs, with the last cdr being an empty list. Sometimes such diagrams can be helpful in understanding how lists are constructed recursively.

(define (accumulate op initial sequence) (if (null? sequence) initial (op (car sequence) (accumulate op initial (cdr sequence))))) (define (map p sequence) (accumulate (lambda (x y) (cons (p x) y)) '() sequence)) (define (append seq1 seq2) (accumulate cons seq2 seq1)) (define (length sequence) (accumulate (lambda (x y) (+ 1 y)) 0 sequence))

(define (leaf? t) (not (pair? t))) (define (count-leaves t) (accumulate + 0 (map (lambda (node) (if (leaf? node) 1 (count-leaves node))) t)))