Run Resyntax on drracket/private

Fixed 14 issues in 6 files.

  * Fixed 6 occurences of let-to-define
  * Fixed 3 occurences of cond-let-to-cond-define
  * Fixed 3 occurences of if-let-to-cond
  * Fixed 2 occurences of single-argument-plus-to-identity

Author: jackfirth

drracket/drracket/private/drracket-normal.rkt

@@ -219,10 +219,10 @@
     [(or (prince-kuhio-day? startup-date)
          (kamehameha-day? startup-date))
      (set-splash-progress-bar?! #f)
-     (let ([size ((dynamic-require 'drracket/private/palaka 'palaka-pattern-size) 4)])
-       (vector (dynamic-require 'drracket/private/honu-logo 'draw-honu) 
-               size 
-               size))]
+     (define size ((dynamic-require 'drracket/private/palaka 'palaka-pattern-size) 4))
+     (vector (dynamic-require 'drracket/private/honu-logo 'draw-honu) 
+             size 
+             size)]
     [(ada-lovelace-bday? startup-date)
      (set-splash-progress-bar?! #f)
      (define size (dynamic-require 'drracket/private/ada 'ada-size))

drracket/drracket/private/embedded-snip-utils.rkt

@@ -8,16 +8,17 @@
 ;; Returns the enclosing frame of an-editor, or #f if we can't find it.
 (define (get-enclosing-editor-frame an-editor)
   (define (topwin)
-    (let ([canvas (send an-editor get-canvas)])
-      (and canvas (send canvas get-top-level-window))))
+    (define canvas (send an-editor get-canvas))
+    (and canvas (send canvas get-top-level-window)))
   (define admin (send an-editor get-admin))
-  (if (and admin (is-a? admin editor-snip-editor-admin<%>))
-      (let ([enclosing-editor-snip (send admin get-snip)])
-        (if (get-snip-outer-editor enclosing-editor-snip)
-            (get-enclosing-editor-frame (get-snip-outer-editor
-                                         enclosing-editor-snip))
-            (topwin)))
-      (topwin)))
+  (cond
+    [(and admin (is-a? admin editor-snip-editor-admin<%>))
+     (define enclosing-editor-snip (send admin get-snip))
+     (if (get-snip-outer-editor enclosing-editor-snip)
+         (get-enclosing-editor-frame (get-snip-outer-editor
+                                      enclosing-editor-snip))
+         (topwin))]
+    [else (topwin)]))
 
 ;; get-snip-outer-editor: snip% -> (or/c editor<%> #f)
 ;; Returns the immediate outer editor enclosing the snip, or false if we

drracket/drracket/private/eval.rkt

@@ -38,42 +38,44 @@
          init
          kill-termination
          #:gui-modules? gui-modules?))
-      (let ([language (drracket:language-configuration:language-settings-language
-                       language-settings)]
-            [settings (drracket:language-configuration:language-settings-settings
-                       language-settings)])
-        (λ (input iter complete-program?)
-          (define port
-            (cond
-              [(input-port? input) input]
-              [else (let* ([text (drracket:language:text/pos-text input)]
-                           [start (drracket:language:text/pos-start input)]
-                           [end (drracket:language:text/pos-end input)]
-                           [text-port (open-input-text-editor text start end values
-                                                              (send text get-port-name))])
-                      (port-count-lines! text-port)
-                      (let* ([line (send text position-paragraph start)]
-                             [column (- start (send text paragraph-start-position line))]
-                             [relocated-port (relocate-input-port text-port 
-                                                                  (+ line 1)
-                                                                  column
-                                                                  (+ start 1))])
-                        (port-count-lines! relocated-port)
-                        relocated-port))]))
-          (parameterize ([current-eventspace eventspace])
-            (queue-callback
-             (λ ()
-               (let ([read-thnk 
-                      (if complete-program?
-                          (send language front-end/complete-program port settings)
-                          (send language front-end/interaction port settings))])
-                 (let loop ()
-                   (let ([in (read-thnk)])
-                     (cond
-                       [(eof-object? in)
-                        (iter in (λ () (void)))]
-                       [else
-                        (iter in (λ () (loop)))]))))))))))
+      (define language
+        (drracket:language-configuration:language-settings-language
+         language-settings))
+      (define settings
+        (drracket:language-configuration:language-settings-settings
+         language-settings))
+      (λ (input iter complete-program?)
+        (define port
+          (cond
+            [(input-port? input) input]
+            [else (let* ([text (drracket:language:text/pos-text input)]
+                         [start (drracket:language:text/pos-start input)]
+                         [end (drracket:language:text/pos-end input)]
+                         [text-port (open-input-text-editor text start end values
+                                                            (send text get-port-name))])
+                    (port-count-lines! text-port)
+                    (let* ([line (send text position-paragraph start)]
+                           [column (- start (send text paragraph-start-position line))]
+                           [relocated-port (relocate-input-port text-port 
+                                                                (+ line 1)
+                                                                column
+                                                                (+ start 1))])
+                      (port-count-lines! relocated-port)
+                      relocated-port))]))
+        (parameterize ([current-eventspace eventspace])
+          (queue-callback
+           (λ ()
+             (let ([read-thnk 
+                    (if complete-program?
+                        (send language front-end/complete-program port settings)
+                        (send language front-end/interaction port settings))])
+               (let loop ()
+                 (let ([in (read-thnk)])
+                   (cond
+                     [(eof-object? in)
+                      (iter in (λ () (void)))]
+                     [else
+                      (iter in (λ () (loop)))])))))))))
 
     (define (expand-program/multiple language-settings
                                      eval-compile-time-part? 
@@ -83,16 +85,15 @@
       (define res
         (traverse-program/multiple language-settings init kill-termination #:gui-modules? gui-modules?))
       (λ (input iter complete-program?)
-        (let ([expanding-iter
-               (λ (rd cont)
-                 (cond
-                   [(eof-object? rd) (iter rd cont)]
-                   [eval-compile-time-part? 
-                    (iter (expand-top-level-with-compile-time-evals rd) cont)]
-                   [else (iter (expand rd) cont)]))])
-          (res input 
-               expanding-iter
-               complete-program?))))
+        (define (expanding-iter rd cont)
+          (cond
+            [(eof-object? rd) (iter rd cont)]
+            [eval-compile-time-part? 
+             (iter (expand-top-level-with-compile-time-evals rd) cont)]
+            [else (iter (expand rd) cont)]))
+        (res input 
+             expanding-iter
+             complete-program?)))
 
     (define (expand-program input
                             language-settings
@@ -126,19 +127,19 @@
       (define eventspace-main-thread #f)
       (define (run-in-eventspace thnk)
         (parameterize ([current-eventspace eventspace])
-          (let ([sema (make-semaphore 0)]
-                [ans #f])
-            (queue-callback
-             (λ ()
-               (let/ec k
-                 (parameterize ([error-escape-handler
-                                 (let ([drscheme-expand-program-error-escape-handler
-                                        (λ () (k (void)))])
-                                   drscheme-expand-program-error-escape-handler)])
-                   (set! ans (thnk))))
-               (semaphore-post sema)))
-            (semaphore-wait sema)
-            ans)))
+          (define sema (make-semaphore 0))
+          (define ans #f)
+          (queue-callback
+           (λ ()
+             (let/ec k
+               (parameterize ([error-escape-handler
+                               (let ([drscheme-expand-program-error-escape-handler
+                                      (λ () (k (void)))])
+                                 drscheme-expand-program-error-escape-handler)])
+                 (set! ans (thnk))))
+             (semaphore-post sema)))
+          (semaphore-wait sema)
+          ans))
       (define drs-snip-classes (get-snip-classes))
       (run-in-eventspace
        (λ ()
@@ -225,11 +226,11 @@
         (close-input-port p)
         (cond
           [(equal? chars (string->list "WXME"))
-           (let ([text (make-object text%)])
-             (send text load-file filename)
-             (let ([port (open-input-text-editor text)])
-               (port-count-lines! port)
-               (values port text)))]
+           (define text (make-object text%))
+           (send text load-file filename)
+           (let ([port (open-input-text-editor text)])
+             (port-count-lines! port)
+             (values port text))]
           [else
            (define port (open-input-file filename))
            (port-count-lines! port)

drracket/drracket/private/frame.rkt

@@ -783,12 +783,13 @@
 
       (define/private (filter-search bindings)
         (define str (send search-field get-value))
-        (if (equal? str "")
-            bindings
-            (let ([reg (regexp (regexp-quote str #f))])
-              (filter (λ (x) (or (regexp-match reg (cadr x))
-                                 (regexp-match reg (format "~a" (car x)))))
-                      bindings))))
+        (cond
+          [(equal? str "") bindings]
+          [else
+           (define reg (regexp (regexp-quote str #f)))
+           (filter (λ (x) (or (regexp-match reg (cadr x))
+                              (regexp-match reg (format "~a" (car x)))))
+                   bindings)]))
       (send search-field focus)
       (send bp stretchable-height #f)
       (send bp set-alignment 'center 'center)

drracket/drracket/private/module-browser.rkt

@@ -118,14 +118,15 @@
        (λ (filename)
          (define p (open-input-file filename))
          (define wxme? (regexp-match-peek #rx#"^WXME" p))
-         (if wxme?
-             (let ([t (new text%)])
-               (close-input-port p)
-               (send t load-file filename)
-               (let ([prt (open-input-text-editor t)])
-                 (port-count-lines! prt)
-                 prt))
-             p)))
+         (cond
+           [wxme?
+            (define t (new text%))
+            (close-input-port p)
+            (send t load-file filename)
+            (let ([prt (open-input-text-editor t)])
+              (port-count-lines! prt)
+              prt)]
+           [else p])))
       (current-output-port (swallow-specials original-output-port))
       (current-error-port (swallow-specials original-error-port))
       (current-load-relative-directory #f)

drracket/drracket/private/stick-figures.rkt

@@ -105,62 +105,58 @@
   (define-values (max-rx max-ry) (get-max/min-x/y max running-points))
   (define-values (min-wx min-wy) (get-max/min-x/y min waiting-points))
   (define-values (max-wx max-wy) (get-max/min-x/y max waiting-points))
-  (let* ([running-w (* small-factor (- max-rx min-rx))]
-         [waiting-w (* small-factor (- max-wx min-wx))]
-         [running-h (* small-factor (- max-ry min-ry))]
-         [waiting-h (* small-factor (- max-wy min-wy))]
-         [w (+ 2 (ceiling (max running-w waiting-w)))]
-         [h (+ 2 (ceiling (max running-h waiting-h)))]
-         [running-dx (+ 1 (- (/ w 2) (/ running-w 2)))]
-         [running-dy (+ 1 (- (/ h 2) (/ running-h 2)))]
-         [waiting-dx (+ 1 (- (/ w 2) (/ waiting-w 2)))]
-         [waiting-dy (+ 1 (- (/ h 2) (/ waiting-h 2)))])
-    (values w h running-dx running-dy waiting-dx waiting-dy)))
+  (define running-w (* small-factor (- max-rx min-rx)))
+  (define waiting-w (* small-factor (- max-wx min-wx)))
+  (define running-h (* small-factor (- max-ry min-ry)))
+  (define waiting-h (* small-factor (- max-wy min-wy)))
+  (define w (+ 2 (ceiling (max running-w waiting-w))))
+  (define h (+ 2 (ceiling (max running-h waiting-h))))
+  (define running-dx (+ 1 (- (/ w 2) (/ running-w 2))))
+  (define running-dy (+ 1 (- (/ h 2) (/ running-h 2))))
+  (define waiting-dx (+ 1 (- (/ w 2) (/ waiting-w 2))))
+  (define waiting-dy (+ 1 (- (/ h 2) (/ waiting-h 2))))
+  (values w h running-dx running-dy waiting-dx waiting-dy))
 
   (define (get-bitmap points green)
   (define-values (min-rx min-ry) (get-max/min-x/y min points))
   (define-values (max-rx max-ry) (get-max/min-x/y max points))
-  (let* ([margin 2]
-         [bw (+ margin margin (ceiling (* small-factor (- max-rx min-rx))))]
-         [bh (+ margin margin (ceiling (* small-factor (- max-ry min-ry))))]
-         [w (ceiling (* bw small-bitmap-factor))] 
-         [h (ceiling (* bh small-bitmap-factor))]
-         [bm-big (make-object bitmap% bw bh)]
-         [bm-solid (make-object bitmap% w h)]
-         [bm-small (make-object bitmap% w h)]
-         [bdc-big (make-object bitmap-dc% bm-big)]
-         [bdc-solid (make-object bitmap-dc% bm-solid)]
-         [bdc-small (make-object bitmap-dc% bm-small)])
-    (send bdc-big clear)
-    (draw-callback bdc-big small-factor #f points
-                   (+ margin (- (* small-factor min-rx)))
-                   (+ margin #;(- (* small-factor min-ry)))
-                   3)
-        
-    (send bdc-small clear)
-    (send bdc-small set-scale small-bitmap-factor small-bitmap-factor)
-    (send bdc-small draw-bitmap bm-big 0 0)
-    (send bdc-small set-scale 1 1)
-        
-    (send bdc-solid set-brush green 'solid)
-    (send bdc-solid set-pen green 1 'solid)
-    (send bdc-solid draw-rectangle 0 0 w h)
-        
-    (send bdc-solid set-bitmap #f)
-    (send bdc-small set-bitmap #f)
-    (send bdc-big set-bitmap #f)
-        
-    (send bm-solid set-loaded-mask bm-small)
-    bm-solid))
+  (define margin 2)
+  (define bw (+ margin margin (ceiling (* small-factor (- max-rx min-rx)))))
+  (define bh (+ margin margin (ceiling (* small-factor (- max-ry min-ry)))))
+  (define w (ceiling (* bw small-bitmap-factor)))
+  (define h (ceiling (* bh small-bitmap-factor)))
+  (define bm-big (make-object bitmap% bw bh))
+  (define bm-solid (make-object bitmap% w h))
+  (define bm-small (make-object bitmap% w h))
+  (define bdc-big (make-object bitmap-dc% bm-big))
+  (define bdc-solid (make-object bitmap-dc% bm-solid))
+  (define bdc-small (make-object bitmap-dc% bm-small))
+  (send bdc-big clear)
+  (draw-callback bdc-big small-factor #f points
+                 (+ margin (- (* small-factor min-rx)))
+                 (+ margin #;(- (* small-factor min-ry)))
+                 3)
+  (send bdc-small clear)
+  (send bdc-small set-scale small-bitmap-factor small-bitmap-factor)
+  (send bdc-small draw-bitmap bm-big 0 0)
+  (send bdc-small set-scale 1 1)
+  (send bdc-solid set-brush green 'solid)
+  (send bdc-solid set-pen green 1 'solid)
+  (send bdc-solid draw-rectangle 0 0 w h)
+  (send bdc-solid set-bitmap #f)
+  (send bdc-small set-bitmap #f)
+  (send bdc-big set-bitmap #f)
+  (send bm-solid set-loaded-mask bm-small)
+  bm-solid)
 
   (define (get-running-bitmap) (get-bitmap running-points (make-object color% 30 100 30)))
   (define (get-waiting-bitmap) (get-bitmap waiting-points (make-object color% 30 100 30)))
 
   (define (normalize points)
   (define-values (min-x min-y) (get-max/min-x/y min points))
   (map (λ (x) (list (car x) 
-                    (+ (- (list-ref x 1) min-x))
-                    (+ (- (list-ref x 2) min-y))))
+                    (- (list-ref x 1) min-x)
+                    (- (list-ref x 2) min-y)))
        points))
 
   (define (get-max/min-x/y choose points)
@@ -242,16 +238,16 @@
           (cond
             [(send evt button-down? 'left)
              (define-values (w h) (get-client-size))
-             (let ([x (send evt get-x)]
-                   [y (send evt get-y)])
-               (let ([point (find-point this x y)])
-                 (when point
-                   (set! clicked-x x)
-                   (set! clicked-y y)
-                   (set! clicked-point point)
-                   (let ([orig-point (assoc point points)])
-                     (set! orig-x (list-ref orig-point 1))
-                     (set! orig-y (list-ref orig-point 2))))))]
+             (define x (send evt get-x))
+             (define y (send evt get-y))
+             (let ([point (find-point this x y)])
+               (when point
+                 (set! clicked-x x)
+                 (set! clicked-y y)
+                 (set! clicked-point point)
+                 (let ([orig-point (assoc point points)])
+                   (set! orig-x (list-ref orig-point 1))
+                   (set! orig-y (list-ref orig-point 2)))))]
             [(and clicked-point (send evt moving?))
              (set! points 
                    (map (λ (x)