diff --git a/scribble-lib/scribble/contract-render.rkt b/scribble-lib/scribble/contract-render.rkt
index 4e9782a81a..11d14a8923 100644
--- a/scribble-lib/scribble/contract-render.rkt
+++ b/scribble-lib/scribble/contract-render.rkt
@@ -116,7 +116,7 @@
   
   ;; we just take the first one here
   (define background-label-p (open-input-string (get-output-string background-label-port)))
-  (define background-label-line (read-line background-label-p))
+  (define background-label-line (read-line background-label-p 'any))
   
   (define text-p (the-text-p))
   (define-values (before-line _1 _2) (port-next-location text-p))
@@ -130,7 +130,7 @@
   ;; the spaces that appear at the ends of the lines
   (let ([p (open-input-string (get-output-string block-port))])
     (let loop ()
-      (define l (read-line p))
+      (define l (read-line p 'any))
       (unless (eof-object? l)
         (display (regexp-replace #rx" *$" l "") text-p)
         (newline text-p)
@@ -145,9 +145,9 @@
 
 (define (r-blockss+cont blockss mode index-table)
   (for* ([blocks (in-list blockss)]
-         [block (in-list blocks)])
-    (unless (eq? block 'cont)
-      (r-block block mode index-table))))
+         [block (in-list blocks)]
+         #:unless (eq? block 'cont))
+    (r-block block mode index-table)))
 
 (define (r-blockss blockss mode index-table)
   (for ([blocks (in-list blockss)])
diff --git a/scribble-lib/scribble/example.rkt b/scribble-lib/scribble/example.rkt
index 9f0ccf6dde..2e41f54c7a 100644
--- a/scribble-lib/scribble/example.rkt
+++ b/scribble-lib/scribble/example.rkt
@@ -94,11 +94,10 @@
                       (attribute no-result-kw)
                       (attribute no-form-kw))))
          (with-syntax ([srcloced-form srcloced-form]
-                       [title (or (attribute title)
-                                  (cond
-                                   [(= 1 (length (syntax->list #'(form ...))))
-                                    #'example-title]
-                                   [else #'examples-title]))])
+                       [title (cond
+                                [(attribute title) #t]
+                                [(= 1 (length (syntax->list #'(form ...)))) #'example-title]
+                                [else #'examples-title])])
            (syntax/loc stx (as-examples title srcloced-form)))]
         [else
          srcloced-form]))
diff --git a/scribble-lib/scribble/markdown-render.rkt b/scribble-lib/scribble/markdown-render.rkt
index a75e358471..04c36c89cc 100644
--- a/scribble-lib/scribble/markdown-render.rkt
+++ b/scribble-lib/scribble/markdown-render.rkt
@@ -118,12 +118,11 @@
                                          (regexp-replace #rx"\n$" (get-output-string o) ""))]))
                                    flows))
                             flowss))
-          (define widths (map (lambda (col)
-                                (for/fold ([d 0]) ([i (in-list col)])
-                                  (if (eq? i 'cont)
-                                      0
-                                      (apply max d (map string-length i)))))
-                              (apply map list strs)))
+          (define widths (for/list ([col (in-list (apply map list strs))])
+                           (for/fold ([d 0]) ([i (in-list col)])
+                             (if (eq? i 'cont)
+                                 0
+                                 (apply max d (map string-length i))))))
           (define (x-length col)
             (if (eq? col 'cont) 0 (length col)))
           (for/fold ([indent? #f]) ([row (in-list strs)])
diff --git a/scribble-lib/scribble/search.rkt b/scribble-lib/scribble/search.rkt
index aa41892ee4..44cc07961d 100644
--- a/scribble-lib/scribble/search.rkt
+++ b/scribble-lib/scribble/search.rkt
@@ -93,10 +93,11 @@
               (list* (module-path-index->taglet mod)
                      id
                      (if suffix (list suffix) null)))
-            (when (not search-key)
-              (set! search-key (if unlinked-ok?
-                                   (cons #f eb)
-                                   eb)))
+            (unless search-key
+              (set! search-key
+                    (if unlinked-ok?
+                        (cons #f eb)
+                        eb)))
             (define v (and eb (resolve-search search-key part ri `(dep ,eb))))
             (define here-result
               (and need-result?
@@ -164,37 +165,35 @@
                         (hash-set! module-info-cache rmp t)
                         t)))
                    (hash-set! seen (cons export-phase rmp) #t)
-                   (let ([a (assq id (let ([a (assoc export-phase exports)])
-                                       (if a
-                                           (cdr a) 
-                                           null)))])
-                     (cond
-                       [a
-                        (loop queue
-                              (append (map (lambda (m)
-                                             (if (pair? m)
-                                                 (list (module-path-index-rejoin (car m) mod)
-                                                       (list-ref m 2)
-                                                       defn-phase
-                                                       (list-ref m 1)
-                                                       (list-ref m 3))
-                                                 (list (module-path-index-rejoin m mod)
-                                                       id
-                                                       defn-phase
-                                                       import-phase
-                                                       export-phase)))
-                                           (reverse (cadr a)))
-                                      rqueue)
-                              need-result?)]
-                       [else
-                        ;; A dead end may not be our fault: the files could
-                        ;; have changed in inconsistent ways. So just say #f
-                        ;; for now.
-                        #;
-                        (error 'find-racket-tag
-                               "dead end when looking for binding source: ~e"
-                               id)
-                        (loop queue rqueue need-result?)]))]
+                   (define a
+                     (assq id
+                           (let ([a (assoc export-phase exports)])
+                             (if a
+                                 (cdr a)
+                                 null))))
+                   (cond
+                     [a
+                      (loop queue
+                            (append (map (lambda (m)
+                                           (if (pair? m)
+                                               (list (module-path-index-rejoin (car m) mod)
+                                                     (list-ref m 2)
+                                                     defn-phase
+                                                     (list-ref m 1)
+                                                     (list-ref m 3))
+                                               (list (module-path-index-rejoin m mod)
+                                                     id
+                                                     defn-phase
+                                                     import-phase
+                                                     export-phase)))
+                                         (reverse (cadr a)))
+                                    rqueue)
+                            need-result?)]
+                     ;; A dead end may not be our fault: the files could
+                     ;; have changed in inconsistent ways. So just say #f
+                     ;; for now.
+                     #;(error 'find-racket-tag "dead end when looking for binding source: ~e" id)
+                     [else (loop queue rqueue need-result?)])]
                   [else
                    ;; Can't get the module source, so continue with queue:
                    (loop queue rqueue need-result?)]))
diff --git a/scribble-lib/scribble/srcdoc.rkt b/scribble-lib/scribble/srcdoc.rkt
index 8a8d306da4..3bf1ec147c 100644
--- a/scribble-lib/scribble/srcdoc.rkt
+++ b/scribble-lib/scribble/srcdoc.rkt
@@ -74,18 +74,15 @@
     (syntax-local-introduce
      (syntax-shift-phase-level s #f)))
   (with-syntax ([((req ...) ...)
-                 (map (lambda (rs)
-                        (map (lambda (r)
-                               (syntax-case r ()
-                                 [(op arg ...)
-                                  (with-syntax ([(arg ...)
-                                                 (map shift-and-introduce
-                                                      (syntax->list #'(arg ...)))])
-                                    #'(op arg ...))]
-                                 [else
-                                  (shift-and-introduce r)]))
-                             (syntax->list rs)))
-                      (reverse requires))]
+                 (for/list ([rs (in-list (reverse requires))])
+                   (map (lambda (r)
+                          (syntax-case r ()
+                            [(op arg ...)
+                             (with-syntax ([(arg ...) (map shift-and-introduce
+                                                           (syntax->list #'(arg ...)))])
+                               #'(op arg ...))]
+                            [else (shift-and-introduce r)]))
+                        (syntax->list rs)))]
                 [(expr ...)
                  (map shift-and-introduce (reverse doc-exprs))]
                 [doc-body
@@ -124,30 +121,19 @@
 (define-for-syntax (do-provide/doc stx modes)
   (let ([forms (list stx)])
     (with-syntax ([((for-provide/contract (req ...) d id) ...)
-                   (map (lambda (form)
-                          (syntax-case form ()
-                            [(id . _)
-                             (identifier? #'id)
-                             (let ([t (syntax-local-value #'id (lambda () #f))])
-                               (unless (provide/doc-transformer? t)
-                                 (raise-syntax-error
-                                  #f
-                                  "not bound as a provide/doc transformer"
-                                  stx
-                                  #'id))
-                               (let* ([i (make-syntax-introducer)]
-                                      [i2 (lambda (x) (syntax-local-introduce (i x)))])
-                                 (let-values ([(p/c d req/d id)
-                                               ((provide/doc-transformer-proc t)
-                                                (i (syntax-local-introduce form)))])
-                                   (list (i2 p/c) (i req/d) (i d) (i id)))))]
-                            [_
-                             (raise-syntax-error
-                              #f
-                              "not a provide/doc sub-form"
-                              stx
-                              form)]))
-                        forms)])
+                   (for/list ([form (in-list forms)])
+                     (syntax-case form ()
+                       [(id . _)
+                        (identifier? #'id)
+                        (let ([t (syntax-local-value #'id (lambda () #f))])
+                          (unless (provide/doc-transformer? t)
+                            (raise-syntax-error #f "not bound as a provide/doc transformer" stx #'id))
+                          (let* ([i (make-syntax-introducer)]
+                                 [i2 (lambda (x) (syntax-local-introduce (i x)))])
+                            (let-values ([(p/c d req/d id) ((provide/doc-transformer-proc t)
+                                                            (i (syntax-local-introduce form)))])
+                              (list (i2 p/c) (i req/d) (i d) (i id)))))]
+                       [_ (raise-syntax-error #f "not a provide/doc sub-form" stx form)]))])
       (with-syntax ([(p/c ...)
                      (map (lambda (form f)
                             (if (identifier? f)
@@ -359,44 +345,52 @@
                             
                             (let ([build-mandatories/optionals
                                    (λ (names contracts extras)
-                                     (let ([names-length (length names)]
-                                           [contracts-length (length contracts)])
-                                       (let loop ([contracts contracts]
-                                                  [names names]
-                                                  [extras extras])
-                                         (cond
-                                           [(and (null? names) (null? contracts)) '()]
-                                           [(or (null? names) (null? contracts))
-                                            (raise-syntax-error #f
-                                                                (format "mismatched ~a argument list count and domain contract count (~a)"
-                                                                        (if extras "optional" "mandatory")
-                                                                        (if (null? names)
-                                                                            "ran out of names"
-                                                                            "ran out of contracts"))
-                                                                stx)]
-                                           [else
-                                            (let ([fst-name (car names)]
-                                                  [fst-ctc (car contracts)])
-                                              (if (keyword? (syntax-e fst-ctc))
-                                                  (begin
-                                                    (unless (pair? (cdr contracts))
-                                                      (raise-syntax-error #f
-                                                                          "keyword not followed by a contract"
-                                                                          stx))
-                                                    (cons (if extras
-                                                              (list fst-ctc fst-name (cadr contracts) (car extras))
-                                                              (list fst-ctc fst-name (cadr contracts)))
-                                                          (loop (cddr contracts)
-                                                                (cdr names)
-                                                                (if extras
-                                                                    (cdr extras)
-                                                                    extras))))
-                                                  (cons (if extras 
-                                                            (list fst-name fst-ctc (car extras))
-                                                            (list fst-name fst-ctc))
-                                                        (loop (cdr contracts) (cdr names) (if extras
-                                                                                              (cdr extras)
-                                                                                              extras)))))]))))])
+                                     (length names)
+                                     (length contracts)
+                                     (let loop ([contracts contracts]
+                                                [names names]
+                                                [extras extras])
+                                       (cond
+                                         [(and (null? names) (null? contracts)) '()]
+                                         [(or (null? names) (null? contracts))
+                                          (raise-syntax-error
+                                           #f
+                                           (format
+                                            "mismatched ~a argument list count and domain contract count (~a)"
+                                            (if extras "optional" "mandatory")
+                                            (if (null? names)
+                                                "ran out of names"
+                                                "ran out of contracts"))
+                                           stx)]
+                                         [else
+                                          (let ([fst-name (car names)]
+                                                [fst-ctc (car contracts)])
+                                            (if (keyword? (syntax-e fst-ctc))
+                                                (begin
+                                                  (unless (pair? (cdr contracts))
+                                                    (raise-syntax-error
+                                                     #f
+                                                     "keyword not followed by a contract"
+                                                     stx))
+                                                  (cons (if extras
+                                                            (list fst-ctc
+                                                                  fst-name
+                                                                  (cadr contracts)
+                                                                  (car extras))
+                                                            (list fst-ctc fst-name (cadr contracts)))
+                                                        (loop (cddr contracts)
+                                                              (cdr names)
+                                                              (if extras
+                                                                  (cdr extras)
+                                                                  extras))))
+                                                (cons (if extras
+                                                          (list fst-name fst-ctc (car extras))
+                                                          (list fst-name fst-ctc))
+                                                      (loop (cdr contracts)
+                                                            (cdr names)
+                                                            (if extras
+                                                                (cdr extras)
+                                                                extras)))))])))])
                             
                               #`([(id #,@(build-mandatories/optionals (syntax->list #'(mandatory-names ...))
                                                                       (syntax->list #'(mandatory ...))
@@ -418,19 +412,22 @@
                                 [((x y) ...)
                                  (andmap identifier? (syntax->list #'(x ... y ...)))]
                                 [((x y) ...)
-                                 (for-each
-                                  (λ (var) 
-                                    (unless (identifier? var)
-                                      (raise-syntax-error #f "expected an identifier in the optional names" stx var)))
-                                  (syntax->list #'(x ... y ...)))]
+                                 (for ([var (in-list (syntax->list #'(x ... y ...)))])
+                                   (unless (identifier? var)
+                                     (raise-syntax-error
+                                      #f
+                                      "expected an identifier in the optional names"
+                                      stx
+                                      var)))]
                                 [(a ...)
-                                 (for-each
-                                  (λ (a)
-                                    (syntax-case stx ()
-                                      [(x y) (void)]
-                                      [other
-                                       (raise-syntax-error #f "expected an sequence of two idenfiers" stx #'other)]))
-                                  (syntax->list #'(a ...)))]))]
+                                 (for ([a (in-list (syntax->list #'(a ...)))])
+                                   (syntax-case stx ()
+                                     [(x y) (void)]
+                                     [other
+                                      (raise-syntax-error #f
+                                                          "expected an sequence of two idenfiers"
+                                                          stx
+                                                          #'other)]))]))]
                            [x
                             (raise-syntax-error
                              #f
@@ -506,12 +503,9 @@
                               "expected an identifier or sequence of two identifiers"
                               stx
                               #'struct-name)])
-       (for ([f (in-list (syntax->list #'(field-name ...)))])
-         (unless (identifier? f)
-           (raise-syntax-error #f 
-                               "expected an identifier"
-                               stx
-                               f)))
+       (for ([f (in-list (syntax->list #'(field-name ...)))]
+             #:unless (identifier? f))
+         (raise-syntax-error #f "expected an identifier" stx f))
        (define omit-constructor? #f)
        (define-values (ds-args desc)
          (let loop ([ds-args '()]
diff --git a/scribble-lib/scribble/text-render.rkt b/scribble-lib/scribble/text-render.rkt
index e524ea5f17..16fa84493f 100644
--- a/scribble-lib/scribble/text-render.rkt
+++ b/scribble-lib/scribble/text-render.rkt
@@ -37,18 +37,14 @@
     (define/override (render-part d ht)
       (let ([number (collected-info-number (part-collected-info d ht))])
         (unless (part-style? d 'hidden)
-          (let ([s (format-number number '() #t)])
-            (unless (null? s)
-              (printf "~a~a" 
-                      (car s)
-                      (if (part-title-content d)
-                          " "
-                          "")))
-            (when (part-title-content d)
-              (render-content (part-title-content d) d ht))
-            (when (or (pair? number) (part-title-content d))
-              (newline)
-              (newline))))
+          (define s (format-number number '() #t))
+          (unless (null? s)
+            (printf "~a~a" (car s) (if (part-title-content d) " " "")))
+          (when (part-title-content d)
+            (render-content (part-title-content d) d ht))
+          (when (or (pair? number) (part-title-content d))
+            (newline)
+            (newline)))
         (render-flow (part-blocks d) d ht #f)
         (let loop ([pos 1]
                    [secs (part-parts d)]
@@ -300,12 +296,12 @@
     (define/override (render-nested-flow i part ri starting-item?)
       (define s (nested-flow-style i))
       (unless (memq 'decorative (style-properties s))
-        (if (and s (or (eq? (style-name s) 'inset)
-                       (eq? (style-name s) 'code-inset)))
-            (begin (printf "  ")
-                   (parameterize ([current-indent (make-indent 2)])
-                     (super render-nested-flow i part ri starting-item?)))
-            (super render-nested-flow i part ri starting-item?))))
+        (cond
+          [(and s (or (eq? (style-name s) 'inset) (eq? (style-name s) 'code-inset)))
+           (printf "  ")
+           (parameterize ([current-indent (make-indent 2)])
+             (super render-nested-flow i part ri starting-item?))]
+          [else (super render-nested-flow i part ri starting-item?)])))
 
     (define/override (render-other i part ht)
       (cond
diff --git a/scribble-lib/scriblib/footnote.rkt b/scribble-lib/scriblib/footnote.rkt
index c40ad6972f..8da1d229dc 100644
--- a/scribble-lib/scriblib/footnote.rkt
+++ b/scribble-lib/scriblib/footnote.rkt
@@ -44,27 +44,19 @@
     (define (footnote-part . text) (do-footnote-part footnotes id))))
 
 (define (do-footnote footnotes id text)
-  (let ([tag (generated-tag)]
-        [content (decode-content text)])
-    (make-traverse-element
-     (lambda (get set)
-       (set id (cons (cons
-                      (make-element footnote-target-style
-                                    (make-element
-                                     'superscript
-                                     (counter-target footnotes tag #f)))
+  (define tag (generated-tag))
+  (define content (decode-content text))
+  (make-traverse-element
+   (lambda (get set)
+     (set id
+          (cons (cons (make-element footnote-target-style
+                                    (make-element 'superscript (counter-target footnotes tag #f)))
                       content)
-                     (get id null)))
-       (make-element footnote-style
-                     (list
-                      (make-element 
-                       footnote-ref-style
-                       (make-element
-                        'superscript
-                        (counter-ref footnotes tag #f)))
-                      (make-element
-                       footnote-content-style
-                       content)))))))
+                (get id null)))
+     (make-element footnote-style
+                   (list (make-element footnote-ref-style
+                                       (make-element 'superscript (counter-ref footnotes tag #f)))
+                         (make-element footnote-content-style content))))))
 
 (define (do-footnote-part footnotes id)
   (make-part
@@ -78,9 +70,6 @@
      (lambda (get set)
        (make-compound-paragraph
         footnote-block-style
-        (map (lambda (content)
-               (make-paragraph
-                footnote-block-content-style
-                content))
-             (reverse (get id null)))))))
+        (for/list ([content (in-list (reverse (get id null)))])
+          (make-paragraph footnote-block-content-style content))))))
    null))
diff --git a/scribble-lib/scriblib/gui-eval.rkt b/scribble-lib/scriblib/gui-eval.rkt
index 69b3ee3576..1bd6567aaf 100644
--- a/scribble-lib/scriblib/gui-eval.rkt
+++ b/scribble-lib/scriblib/gui-eval.rkt
@@ -12,28 +12,26 @@
          racket/sandbox
          (for-syntax racket/base))
 
-(define-syntax define-mr
-  (syntax-rules ()
-    [(_ mr orig)
-     (begin
-       (provide mr)
-       (define-syntax (mr stx)
-         (syntax-case stx ()
-           [(_ #:eval+opts the-eval get-predicate? get-render get-get-width get-get-height x (... ...))
-            #'(let ([the-eval-x the-eval])
-                (parameterize ([scribble-eval-handler (gui-eval-handler the-eval-x
-                                                                        get-predicate?
-                                                                        get-render
-                                                                        get-get-width
-                                                                        get-get-height)])
-                  (orig #:eval the-eval-x x (... ...))))]
-           [(_ x (... ...))
-            #'(parameterize ([scribble-eval-handler (gui-eval-handler gui-eval
-                                                                      (λ () (gui-eval 'pict?))
-                                                                      (λ () (gui-eval 'draw-pict))
-                                                                      (λ () (gui-eval 'pict-width))
-                                                                      (λ () (gui-eval 'pict-height)))])
-                (orig #:eval gui-eval x (... ...)))])))]))
+(define-syntax-rule (define-mr mr orig)
+  (begin
+    (provide mr)
+    (define-syntax (mr stx)
+      (syntax-case stx ()
+        [(_ #:eval+opts the-eval get-predicate? get-render get-get-width get-get-height x (... ...))
+         #'(let ([the-eval-x the-eval])
+             (parameterize ([scribble-eval-handler (gui-eval-handler the-eval-x
+                                                                     get-predicate?
+                                                                     get-render
+                                                                     get-get-width
+                                                                     get-get-height)])
+               (orig #:eval the-eval-x x (... ...))))]
+        [(_ x (... ...))
+         #'(parameterize ([scribble-eval-handler (gui-eval-handler gui-eval
+                                                                   (λ () (gui-eval 'pict?))
+                                                                   (λ () (gui-eval 'draw-pict))
+                                                                   (λ () (gui-eval 'pict-width))
+                                                                   (λ () (gui-eval 'pict-height)))])
+             (orig #:eval gui-eval x (... ...)))]))))
 
 (define gui-eval (make-base-eval #:pretty-print? #f))
 
@@ -68,61 +66,63 @@
                                    "exprs.dat"))
 
 (define gui-eval-handler
-  (if mred?
-      (let ([eh (scribble-eval-handler)]
-            [log-file (open-output-file exprs-dat-file #:exists 'truncate/replace)])
-        (λ (gui-eval get-predicate? get-render get-get-width get-get-height)
-          (lambda (ev catching-exns? expr)
-            (write (serialize (if (syntax? expr) (syntax->datum expr) expr)) log-file)
-            (newline log-file)
-            (flush-output log-file)
-            (let ([result
-                   (with-handlers ([exn:fail?
-                                    (lambda (exn)
-                                      (make-gui-exn (exn-message exn)))])
-                     ;; put the call to fixup-picts in the handlers
-                     ;; so that errors in the user-supplied predicates & 
-                     ;; conversion functions show up in the rendered output
-                     (fixup-picts (get-predicate?) (get-render) (get-get-width) (get-get-height)
-                                  (eh ev catching-exns? expr)))])
-              (write (serialize result) log-file)
-              (newline log-file)
-              (flush-output log-file)
-              (if (gui-exn? result)
-                  (raise (make-exn:fail
-                          (gui-exn-message result)
-                          (current-continuation-marks)))
-                  result)))))
-      (let ([log-file (with-handlers ([exn:fail:filesystem?
-                                       (lambda (exn)
-                                         (open-input-string ""))])
-                        (open-input-file exprs-dat-file))])
-        (λ (gui-eval get-predicate? get-render get-get-width get-get-height)
-          (lambda (ev catching-exns? expr)
-            (with-handlers ([exn:fail? (lambda (exn)
-                                         (if catching-exns?
-                                             (raise exn)
-                                             (void)))])
-              (let ([v (read log-file)])
-                (if (eof-object? v)
-                    (error "expression not in log file")
-                    (let ([v (deserialize v)])
-                      (if (equal? v (if (syntax? expr)
-                                        (syntax->datum expr)
-                                        expr))
-                          (let ([v (read log-file)])
-                            (if (eof-object? v)
-                                (error "expression result missing in log file")
-                                (let ([v (deserialize v)])
-                                  (if (gui-exn? v)
-                                      (raise (make-exn:fail
-                                              (gui-exn-message v)
-                                              (current-continuation-marks)))
-                                      v))))
-                          (error 'mreval
-                                 "expression does not match log file: ~e versus: ~e"
-                                 expr
-                                 v)))))))))))
+  (cond
+    [mred?
+     (define eh (scribble-eval-handler))
+     (define log-file (open-output-file exprs-dat-file #:exists 'truncate/replace))
+     (λ (gui-eval get-predicate? get-render get-get-width get-get-height)
+       (lambda (ev catching-exns? expr)
+         (write (serialize (if (syntax? expr)
+                               (syntax->datum expr)
+                               expr))
+                log-file)
+         (newline log-file)
+         (flush-output log-file)
+         (let ([result (with-handlers ([exn:fail? (lambda (exn) (make-gui-exn (exn-message exn)))])
+                         ;; put the call to fixup-picts in the handlers
+                         ;; so that errors in the user-supplied predicates &
+                         ;; conversion functions show up in the rendered output
+                         (fixup-picts (get-predicate?)
+                                      (get-render)
+                                      (get-get-width)
+                                      (get-get-height)
+                                      (eh ev catching-exns? expr)))])
+           (write (serialize result) log-file)
+           (newline log-file)
+           (flush-output log-file)
+           (if (gui-exn? result)
+               (raise (make-exn:fail (gui-exn-message result) (current-continuation-marks)))
+               result))))]
+    [else
+     (define log-file
+       (with-handlers ([exn:fail:filesystem? (lambda (exn) (open-input-string ""))])
+         (open-input-file exprs-dat-file)))
+     (λ (gui-eval get-predicate? get-render get-get-width get-get-height)
+       (lambda (ev catching-exns? expr)
+         (with-handlers ([exn:fail? (lambda (exn)
+                                      (if catching-exns?
+                                          (raise exn)
+                                          (void)))])
+           (let ([v (read log-file)])
+             (if (eof-object? v)
+                 (error "expression not in log file")
+                 (let ([v (deserialize v)])
+                   (if (equal? v
+                               (if (syntax? expr)
+                                   (syntax->datum expr)
+                                   expr))
+                       (let ([v (read log-file)])
+                         (if (eof-object? v)
+                             (error "expression result missing in log file")
+                             (let ([v (deserialize v)])
+                               (if (gui-exn? v)
+                                   (raise (make-exn:fail (gui-exn-message v)
+                                                         (current-continuation-marks)))
+                                   v))))
+                       (error 'mreval
+                              "expression does not match log file: ~e versus: ~e"
+                              expr
+                              v))))))))]))
 
 (define image-counter 0)
 
@@ -133,41 +133,40 @@
   (let loop ([v v])
     (cond
       [(predicate? v)
-       (let ([fn (build-string-path img-dir
-                                    (format "img~a.png" image-counter))])
-         (set! image-counter (add1 image-counter))
-         (let ([dc (let ([pss (make-object (gui-eval 'ps-setup%))])
-                     (send pss set-mode 'file)
-                     (send pss set-file (path-replace-suffix fn #".pdf"))
-                     (parameterize ([(gui-eval 'current-ps-setup) pss])
-                       (let ([xb (box 0)]
-                             [yb (box 0)])
-                         (send pss get-scaling xb yb)
-                         (new (gui-eval 'pdf-dc%) 
-                              [interactive #f]
-                              [width (* (unbox xb) (get-width v))]
-                              [height (* (unbox yb) (get-height v))]))))])
-           (send dc start-doc "Image")
-           (send dc start-page)
-           (render v dc 0 0)
-           (send dc end-page)
-           (send dc end-doc))
-         (let* ([bm (make-object (gui-eval 'bitmap%)
+       (define fn (build-string-path img-dir (format "img~a.png" image-counter)))
+       (set! image-counter (add1 image-counter))
+       (let ([dc (let ([pss (make-object (gui-eval 'ps-setup%))])
+                   (send pss set-mode 'file)
+                   (send pss set-file (path-replace-suffix fn #".pdf"))
+                   (parameterize ([(gui-eval 'current-ps-setup) pss])
+                     (let ([xb (box 0)]
+                           [yb (box 0)])
+                       (send pss get-scaling xb yb)
+                       (new (gui-eval 'pdf-dc%)
+                            [interactive #f]
+                            [width (* (unbox xb) (get-width v))]
+                            [height (* (unbox yb) (get-height v))]))))])
+         (send dc start-doc "Image")
+         (send dc start-page)
+         (render v dc 0 0)
+         (send dc end-page)
+         (send dc end-doc))
+       (define bm
+         (make-object (gui-eval 'bitmap%)
                       (inexact->exact (ceiling (get-width v)))
-                      (inexact->exact (ceiling (get-height v))))]
-                [dc (make-object (gui-eval 'bitmap-dc%) bm)])
-           (send dc set-smoothing 'aligned)
-           (send dc clear)
-           (render v dc 0 0)
-           (send bm save-file fn 'png)
-           (make-image-element
-            #f
-            (list "[image]")
-            ;; Be sure to use a string rather than a path, because
-            ;; it gets recorded in "exprs.dat".
-            (path->string (path-replace-suffix fn #""))
-            '(".pdf" ".png")
-            1.0)))]
+                      (inexact->exact (ceiling (get-height v)))))
+       (define dc (make-object (gui-eval 'bitmap-dc%) bm))
+       (send dc set-smoothing 'aligned)
+       (send dc clear)
+       (render v dc 0 0)
+       (send bm save-file fn 'png)
+       (make-image-element #f
+                           (list "[image]")
+                           ;; Be sure to use a string rather than a path, because
+                           ;; it gets recorded in "exprs.dat".
+                           (path->string (path-replace-suffix fn #""))
+                           '(".pdf" ".png")
+                           1.0)]
       [(pair? v) (cons (loop (car v))
                        (loop (cdr v)))]
       [(serializable? v) v]