Fix 5 occurrences of let-to-define

resyntax-ci[bot] · resyntax-ci[bot] · commit 00e65ec0ce7e · 2025-07-11T01:58:28.000Z
Internal definitions are recommended instead of `let` expressions, to reduce nesting.
diff --git a/typed-racket-lib/typed-racket/infer/infer-unit.rkt b/typed-racket-lib/typed-racket/infer/infer-unit.rkt
@@ -915,7 +915,8 @@
       [(? variance:const?) S]
       [(? variance:co?) S]
       [(? variance:contra?) T]
-      [(? variance:inv?) (let ([gS (generalize S)]) (if (subtype gS T) gS S))]))
+      [(? variance:inv?) (define gS (generalize S))
+                         (if (subtype gS T) gS S)]))
 
   ;; Since we don't add entries to the empty cset for index variables (since there is no
   ;; widest constraint, due to dcon-exacts), we must add substitutions here if no constraint
diff --git a/typed-racket-lib/typed-racket/typecheck/tc-app-helper.rkt b/typed-racket-lib/typed-racket/typecheck/tc-app-helper.rkt
@@ -328,23 +328,31 @@
                               msg-rngs)
                       ...))
           _))
-     (let ([fcn-string (name->function-str name)])
-       (if (and (andmap null? msg-doms)
-                (null? argtypes))
-           (tc-error/expr (string-append
-                           "Could not infer types for applying polymorphic "
+     (define fcn-string (name->function-str name))
+     (if (and (andmap null? msg-doms) (null? argtypes))
+         (tc-error/expr
+          (string-append "Could not infer types for applying polymorphic " fcn-string "\n"))
+         (domain-mismatches
+          f-stx
+          args-stx
+          t
+          msg-doms
+          msg-rests
+          msg-rngs
+          argtypes
+          #f
+          #f
+          #:expected expected
+          #:msg-thunk
+          (lambda (dom)
+            (string-append "Polymorphic "
                            fcn-string
-                           "\n"))
-           (domain-mismatches f-stx args-stx t msg-doms msg-rests
-                              msg-rngs argtypes #f #f #:expected expected
-                              #:msg-thunk (lambda (dom)
-                                            (string-append
-                                             "Polymorphic " fcn-string " could not be applied to arguments:\n"
-                                             dom
-                                             (if (not (subset? (apply set-union (seteq) (map fv/list msg-doms))
-                                                               (list->seteq msg-vars)))
-                                                 (string-append "Type Variables: " (stringify msg-vars) "\n")
-                                                 ""))))))]
+                           " could not be applied to arguments:\n"
+                           dom
+                           (if (not (subset? (apply set-union (seteq) (map fv/list msg-doms))
+                                             (list->seteq msg-vars)))
+                               (string-append "Type Variables: " (stringify msg-vars) "\n")
+                               "")))))]
     [(Poly-names:
       msg-vars
       (DepFun: raw-domain _ raw-rng))
diff --git a/typed-racket-lib/typed-racket/typecheck/tc-expr-unit.rkt b/typed-racket-lib/typed-racket/typecheck/tc-expr-unit.rkt
@@ -143,8 +143,8 @@
       (dynamic-wind
         (λ () (save-errors!))
         (λ ()
-          (let ([result (tc-expr/check form expected)])
-            (and (not (current-type-error?)) result)))
+          (define result (tc-expr/check form expected))
+          (and (not (current-type-error?)) result))
         (λ () (restore-errors!))))))
 
 (define (tc-expr/check/t? form expected)
diff --git a/typed-racket-lib/typed-racket/typecheck/tc-literal.rkt b/typed-racket-lib/typed-racket/typecheck/tc-literal.rkt
@@ -184,11 +184,11 @@
 (define value->HT
   (case-lambda
    [(check-element h tycon expected-kt expected-vt)
-    (let* ([kts (hash-map h (lambda (x y) (check-element x expected-kt)))]
-           [vts (hash-map h (lambda (x y) (check-element y expected-vt)))]
-           [kt (apply Un kts)]
-           [vt (apply Un vts)])
-      (tycon (check-below kt expected-kt) (check-below vt expected-vt)))]
+    (define kts (hash-map h (lambda (x y) (check-element x expected-kt))))
+    (define vts (hash-map h (lambda (x y) (check-element y expected-vt))))
+    (define kt (apply Un kts))
+    (define vt (apply Un vts))
+    (tycon (check-below kt expected-kt) (check-below vt expected-vt))]
    [(check-element h tycon)
     (define kt (generalize (apply Un (map check-element (hash-keys h)))))
     (define vt (generalize (apply Un (map check-element (hash-values h)))))
diff --git a/typed-racket-test/unit-tests/static-contract-optimizer-tests.rkt b/typed-racket-test/unit-tests/static-contract-optimizer-tests.rkt
@@ -32,13 +32,12 @@
           (make-check-info 'trusted trusted-side)
           (make-check-expected expected))
     (λ ()
-      (let ([opt (optimize argument
-                   #:trusted-positive trusted-positive
-                   #:trusted-negative trusted-negative)])
-        (with-check-info* (list (make-check-actual opt))
-          (lambda ()
-            (unless (equal? opt expected)
-              (fail-check))))))))
+      (define opt
+        (optimize argument #:trusted-positive trusted-positive #:trusted-negative trusted-negative))
+      (with-check-info* (list (make-check-actual opt))
+                        (lambda ()
+                          (unless (equal? opt expected)
+                            (fail-check)))))))
 
 (define-syntax (check-syntax stx)
   (syntax-parse stx
