use closures for tiny speedup

Author: bennn

typed-racket-lib/typed-racket/static-contracts/optimize.rkt

@@ -110,7 +110,7 @@
 
 
 ;; Reduce a static contract assuming that we trusted the current side
-(define (trusted-side-reduce sc flat-sc?)
+(define ((make-trusted-side-reduce flat-sc?) sc)
   (match sc
     [(->/sc: mand-args opt-args mand-kw-args opt-kw-args rest-arg (list (any/sc:) ...))
      (function/sc #t mand-args opt-args mand-kw-args opt-kw-args rest-arg #f)]
@@ -173,7 +173,7 @@
 ;; update-side : sc? weak-side? -> weak-side?
 ;; Change the current side to something safe & strong-as-possible
 ;;  for optimizing the sub-contracts of the given `sc`.
-(define (update-side sc side flat-sc?)
+(define ((make-update-side flat-sc?) sc side)
   (match sc
    [(or/sc: scs ...)
     #:when (not (andmap flat-sc? scs))
@@ -289,24 +289,27 @@
         (sc-map sc trim)]))
   (trim sc 'covariant))
 
+(define (make-sc->kind recursive-kinds)
+  (if recursive-kinds
+    (λ (sc)
+      (let loop ([sc sc])
+        (match sc
+         [(recursive-sc _ _ body)
+          (loop body)]
+         [(or (recursive-sc-use id)
+              (name/sc: id))
+          (hash-ref recursive-kinds id #f)]
+         [_
+          (sc-terminal-kind sc)])))
+    sc-terminal-kind))
 
 ;; If we trust a specific side then we drop all contracts protecting that side.
 (define (optimize sc #:trusted-positive [trusted-positive #f] #:trusted-negative [trusted-negative #f] #:recursive-kinds [recursive-kinds #f])
-  (define sc->kind
-    (if (not recursive-kinds)
-      sc-terminal-kind
-      (λ (sc)
-        (let loop ([sc sc])
-          (match sc
-           [(recursive-sc _ _ body)
-            (loop body)]
-           [(or (recursive-sc-use id)
-                (name/sc: id))
-            (hash-ref recursive-kinds id #f)]
-           [_
-            (sc-terminal-kind sc)])))))
-  (define (flat-sc? sc)
-    (eq? 'flat (sc->kind sc)))
+  (define flat-sc?
+    (let ([sc->kind (make-sc->kind recursive-kinds)])
+      (λ (sc) (eq? 'flat (sc->kind sc)))))
+  (define trusted-side-reduce (make-trusted-side-reduce flat-sc?))
+  (define update-side (make-update-side flat-sc?))
 
   ;; single-step: reduce and trusted-side-reduce if appropriate
   (define (single-step sc maybe-weak-side)
@@ -320,14 +323,14 @@
 
     (reduce
       (if trusted
-          (trusted-side-reduce sc flat-sc?)
+          (trusted-side-reduce sc)
           sc)))
 
   ;; full-pass: single-step at every static contract subpart
   (define (full-pass sc)
     (define ((recur side) sc variance)
       (define curr-side (combine-variance side variance))
-      (define next-side (update-side sc curr-side flat-sc?))
+      (define next-side (update-side sc curr-side))
       (single-step (sc-map sc (recur next-side)) curr-side))
     ((recur 'positive) sc 'covariant))