anchor.diff:        expressions))
     
     (let ((expressions (load-file filename)))
  -    (=> expressions
  -        lint:analyze-for-set
  -        lint:analyze-for-bugged-let
  -        lint:analyze-for-bugged-do
  -        lint:analyze-for-single-clause-ifs)))
  +    (flatten* (map (lambda (f) (f expressions))
  +                   (list lint:analyze-for-set
  +                         lint:analyze-for-bugged-let
  +                         lint:analyze-for-bugged-do
  +                         lint:analyze-for-single-clause-ifs)))))
  
positive.code:       (if (back-reference-found? (cadar bindings) previous-bindings)
            (set! errors (cons (format #f "Back reference in a LET: ~A" (caar bindings)) errors)))))
    
    (define (crawl-looking-for-let expression report)
      (cond ((nil? expression) report)
            ((atom? expression) report)
            ((list? expression)
             (if (eq? (car expression) 'let)
                 (crawl-looking-for-let (cddr expression)
                                        (analyze-let-bindings ((if (symbol? (cadr expression)) caddr cadr) expression)
                                                              report))
                 (list report
                       (crawl-looking-for-let (car expression) '())
                       (crawl-looking-for-let (cdr expression) '()))))
            (else report)))
    
    (remove nil? (flatten* (map (lambda (ex)
                                  (expression-crawler ex
                                                      (lambda (c) (eq? c 'let))
                                                      analyze-let-bindings
                                                      cddr
                                                      '()))
                                expressions))))
  
  
negative.code: (define (lint:analyze-for-bugged-let expressions)
  
    (define (back-reference-found? expr previous-bindings)
      (cond ((nil? expr)
             #f)
            ((atom? expr)
  