diff --git a/pkgs/racket-test-core/tests/racket/hash.rktl b/pkgs/racket-test-core/tests/racket/hash.rktl
index e9943a9505..41c46ad6d5 100644
--- a/pkgs/racket-test-core/tests/racket/hash.rktl
+++ b/pkgs/racket-test-core/tests/racket/hash.rktl
@@ -36,154 +36,181 @@
         h))
 
 (let ()
-  (define (test-hash-iterations lst1 lst2)
-    (define ht/immut (make-immutable-hash (map cons lst1 lst2)))
-    (define ht/mut (make-hash (map cons lst1 lst2)))
-    (define ht/weak (make-weak-hash (map cons lst1 lst2)))
+  (define-syntax (define-hash-iterations-tester stx)
+    (syntax-case stx ()
+     [(_ tag -in-hash -in-pairs -in-keys -in-values)
+      #'(define-hash-iterations-tester tag
+          -in-hash -in-hash -in-hash
+          -in-pairs -in-pairs -in-pairs
+          -in-keys -in-keys -in-keys
+          -in-values -in-values -in-values)]
+     [(_ tag
+         -in-immut-hash -in-mut-hash -in-weak-hash
+         -in-immut-hash-pairs -in-mut-hash-pairs -in-weak-hash-pairs
+         -in-immut-hash-keys -in-mut-hash-keys -in-weak-hash-keys
+         -in-immut-hash-values -in-mut-hash-values -in-weak-hash-values)
+      (with-syntax 
+       ([name 
+         (datum->syntax #'tag 
+           (string->symbol 
+             (format "test-hash-iters-~a" (syntax->datum #'tag))))])
+       #'(define (name lst1 lst2)
+          (define ht/immut (make-immutable-hash (map cons lst1 lst2)))
+          (define ht/mut (make-hash (map cons lst1 lst2)))
+          (define ht/weak (make-weak-hash (map cons lst1 lst2)))
+            
+          (define fake-ht/immut
+            (chaperone-hash 
+                ht/immut
+              (lambda (h k) (values k (lambda (h k v) v))) ; ref-proc
+              (lambda (h k v) values k v) ; set-proc
+              (lambda (h k) k) ; remove-proc
+              (lambda (h k) k))) ; key-proc
+          (define fake-ht/mut
+            (impersonate-hash 
+                ht/mut
+              (lambda (h k) (values k (lambda (h k v) v))) ; ref-proc
+              (lambda (h k v) values k v) ; set-proc
+              (lambda (h k) k) ; remove-proc
+              (lambda (h k) k))) ; key-proc
+          (define fake-ht/weak
+            (impersonate-hash 
+                ht/weak
+              (lambda (h k) (values k (lambda (h k v) v))) ; ref-proc
+              (lambda (h k v) values k v) ; set-proc
+              (lambda (h k) k) ; remove-proc
+              (lambda (h k) k))) ; key-proc
+            
+          (define ht/immut/seq (-in-immut-hash ht/immut))
+          (define ht/mut/seq (-in-mut-hash ht/mut))
+          (define ht/weak/seq (-in-weak-hash ht/weak))
+          (define ht/immut-pair/seq (-in-immut-hash-pairs ht/immut))
+          (define ht/mut-pair/seq (-in-mut-hash-pairs ht/mut))
+          (define ht/weak-pair/seq (-in-weak-hash-pairs ht/weak))
+          (define ht/immut-keys/seq (-in-immut-hash-keys ht/immut))
+          (define ht/mut-keys/seq (-in-mut-hash-keys ht/mut))
+          (define ht/weak-keys/seq (-in-weak-hash-keys ht/weak))
+          (define ht/immut-vals/seq (-in-immut-hash-values ht/immut))
+          (define ht/mut-vals/seq (-in-mut-hash-values ht/mut))
+          (define ht/weak-vals/seq (-in-weak-hash-values ht/weak))
     
-    (define fake-ht/immut
-      (chaperone-hash 
-          ht/immut
-        (lambda (h k) (values k (lambda (h k v) v))) ; ref-proc
-        (lambda (h k v) values k v) ; set-proc
-        (lambda (h k) k) ; remove-proc
-        (lambda (h k) k))) ; key-proc
-    (define fake-ht/mut
-      (impersonate-hash 
-          ht/mut
-        (lambda (h k) (values k (lambda (h k v) v))) ; ref-proc
-        (lambda (h k v) values k v) ; set-proc
-        (lambda (h k) k) ; remove-proc
-        (lambda (h k) k))) ; key-proc
-    (define fake-ht/weak
-      (impersonate-hash 
-          ht/weak
-        (lambda (h k) (values k (lambda (h k v) v))) ; ref-proc
-        (lambda (h k v) values k v) ; set-proc
-        (lambda (h k) k) ; remove-proc
-        (lambda (h k) k))) ; key-proc
+          (test #t =
+           (for/sum ([(k v) (-in-immut-hash ht/immut)]) (+ k v))
+           (for/sum ([(k v) (-in-mut-hash ht/mut)]) (+ k v))
+           (for/sum ([(k v) (-in-weak-hash ht/weak)]) (+ k v))
+           (for/sum ([(k v) (-in-immut-hash fake-ht/immut)]) (+ k v))
+           (for/sum ([(k v) (-in-mut-hash fake-ht/mut)]) (+ k v))
+           (for/sum ([(k v) (-in-weak-hash fake-ht/weak)]) (+ k v))
+           (for/sum ([(k v) ht/immut/seq]) (+ k v))
+           (for/sum ([(k v) ht/mut/seq]) (+ k v))
+           (for/sum ([(k v) ht/weak/seq]) (+ k v))
+           (for/sum ([k+v (-in-immut-hash-pairs ht/immut)])
+             (+ (car k+v) (cdr k+v)))
+           (for/sum ([k+v (-in-mut-hash-pairs ht/mut)])
+             (+ (car k+v) (cdr k+v)))
+           (for/sum ([k+v (-in-weak-hash-pairs ht/weak)])
+             (+ (car k+v) (cdr k+v)))
+           (for/sum ([k+v (-in-immut-hash-pairs fake-ht/immut)]) 
+             (+ (car k+v) (cdr k+v)))
+           (for/sum ([k+v (-in-mut-hash-pairs fake-ht/mut)]) 
+             (+ (car k+v) (cdr k+v)))
+           (for/sum ([k+v (-in-weak-hash-pairs fake-ht/weak)]) 
+             (+ (car k+v) (cdr k+v)))
+           (for/sum ([k+v ht/immut-pair/seq]) (+ (car k+v) (cdr k+v)))
+           (for/sum ([k+v ht/mut-pair/seq]) (+ (car k+v) (cdr k+v)))
+           (for/sum ([k+v ht/weak-pair/seq]) (+ (car k+v) (cdr k+v)))
+           (+ (for/sum ([k (-in-immut-hash-keys ht/immut)]) k)
+              (for/sum ([v (-in-immut-hash-values ht/immut)]) v))
+           (+ (for/sum ([k (-in-mut-hash-keys ht/mut)]) k)
+              (for/sum ([v (-in-mut-hash-values ht/mut)]) v))
+           (+ (for/sum ([k (-in-weak-hash-keys ht/weak)]) k)
+              (for/sum ([v (-in-weak-hash-values ht/weak)]) v))
+           (+ (for/sum ([k (-in-immut-hash-keys fake-ht/immut)]) k)
+              (for/sum ([v (-in-immut-hash-values fake-ht/immut)]) v))
+           (+ (for/sum ([k (-in-mut-hash-keys fake-ht/mut)]) k)
+              (for/sum ([v (-in-mut-hash-values fake-ht/mut)]) v))
+           (+ (for/sum ([k (-in-weak-hash-keys fake-ht/weak)]) k)
+              (for/sum ([v (-in-weak-hash-values fake-ht/weak)]) v))
+           (+ (for/sum ([k ht/immut-keys/seq]) k)
+              (for/sum ([v ht/immut-vals/seq]) v))
+           (+ (for/sum ([k ht/mut-keys/seq]) k)
+              (for/sum ([v ht/mut-vals/seq]) v))
+           (+ (for/sum ([k ht/weak-keys/seq]) k)
+              (for/sum ([v ht/weak-vals/seq]) v)))
+          
+          (test #t =
+           (for/sum ([(k v) (-in-immut-hash ht/immut)]) k)
+           (for/sum ([(k v) (-in-mut-hash ht/mut)]) k)
+           (for/sum ([(k v) (-in-weak-hash ht/weak)]) k)
+           (for/sum ([(k v) (-in-immut-hash fake-ht/immut)]) k)
+           (for/sum ([(k v) (-in-mut-hash fake-ht/mut)]) k)
+           (for/sum ([(k v) (-in-weak-hash fake-ht/weak)]) k)
+           (for/sum ([(k v) ht/immut/seq]) k)
+           (for/sum ([(k v) ht/mut/seq]) k)
+           (for/sum ([(k v) ht/weak/seq]) k)
+           (for/sum ([k+v (-in-immut-hash-pairs ht/immut)]) (car k+v))
+           (for/sum ([k+v (-in-mut-hash-pairs ht/mut)]) (car k+v))
+           (for/sum ([k+v (-in-weak-hash-pairs ht/weak)]) (car k+v))
+           (for/sum ([k+v (-in-immut-hash-pairs fake-ht/immut)]) (car k+v))
+           (for/sum ([k+v (-in-mut-hash-pairs fake-ht/mut)]) (car k+v))
+           (for/sum ([k+v (-in-weak-hash-pairs fake-ht/weak)]) (car k+v))
+           (for/sum ([k+v ht/immut-pair/seq]) (car k+v))
+           (for/sum ([k+v ht/mut-pair/seq]) (car k+v))
+           (for/sum ([k+v ht/weak-pair/seq]) (car k+v))
+           (for/sum ([k (-in-immut-hash-keys ht/immut)]) k)
+           (for/sum ([k (-in-mut-hash-keys ht/mut)]) k)
+           (for/sum ([k (-in-weak-hash-keys ht/weak)]) k)
+           (for/sum ([k (-in-immut-hash-keys fake-ht/immut)]) k)
+           (for/sum ([k (-in-mut-hash-keys fake-ht/mut)]) k)
+           (for/sum ([k (-in-weak-hash-keys fake-ht/weak)]) k)
+           (for/sum ([k ht/immut-keys/seq]) k)
+           (for/sum ([k ht/mut-keys/seq]) k)
+           (for/sum ([k ht/weak-keys/seq]) k))
     
-    (define ht/immut/seq (in-hash ht/immut))
-    (define ht/mut/seq (in-hash ht/mut))
-    (define ht/weak/seq (in-hash ht/weak))
-    (define ht/immut-pair/seq (in-hash-pairs ht/immut))
-    (define ht/mut-pair/seq (in-hash-pairs ht/mut))
-    (define ht/weak-pair/seq (in-hash-pairs ht/weak))
-    (define ht/immut-keys/seq (in-hash-keys ht/immut))
-    (define ht/mut-keys/seq (in-hash-keys ht/mut))
-    (define ht/weak-keys/seq (in-hash-keys ht/weak))
-    (define ht/immut-vals/seq (in-hash-values ht/immut))
-    (define ht/mut-vals/seq (in-hash-values ht/mut))
-    (define ht/weak-vals/seq (in-hash-values ht/weak))
-    
-    (test #t
-          =
-          (for/sum ([(k v) (in-hash ht/immut)]) (+ k v))
-          (for/sum ([(k v) (in-hash ht/mut)]) (+ k v))
-          (for/sum ([(k v) (in-hash ht/weak)]) (+ k v))
-          (for/sum ([(k v) (in-hash fake-ht/immut)]) (+ k v))
-          (for/sum ([(k v) (in-hash fake-ht/mut)]) (+ k v))
-          (for/sum ([(k v) (in-hash fake-ht/weak)]) (+ k v))
-          (for/sum ([(k v) ht/immut/seq]) (+ k v))
-          (for/sum ([(k v) ht/mut/seq]) (+ k v))
-          (for/sum ([(k v) ht/weak/seq]) (+ k v))
-          (for/sum ([k+v (in-hash-pairs ht/immut)]) (+ (car k+v) (cdr k+v)))
-          (for/sum ([k+v (in-hash-pairs ht/mut)]) (+ (car k+v) (cdr k+v)))
-          (for/sum ([k+v (in-hash-pairs ht/weak)]) (+ (car k+v) (cdr k+v)))
-          (for/sum ([k+v (in-hash-pairs fake-ht/immut)]) 
-            (+ (car k+v) (cdr k+v)))
-          (for/sum ([k+v (in-hash-pairs fake-ht/mut)]) 
-            (+ (car k+v) (cdr k+v)))
-          (for/sum ([k+v (in-hash-pairs fake-ht/weak)]) 
-            (+ (car k+v) (cdr k+v)))
-          (for/sum ([k+v ht/immut-pair/seq]) (+ (car k+v) (cdr k+v)))
-          (for/sum ([k+v ht/mut-pair/seq]) (+ (car k+v) (cdr k+v)))
-          (for/sum ([k+v ht/weak-pair/seq]) (+ (car k+v) (cdr k+v)))
-          (+ (for/sum ([k (in-hash-keys ht/immut)]) k)
-             (for/sum ([v (in-hash-values ht/immut)]) v))
-          (+ (for/sum ([k (in-hash-keys ht/mut)]) k)
-             (for/sum ([v (in-hash-values ht/mut)]) v))
-          (+ (for/sum ([k (in-hash-keys ht/weak)]) k)
-             (for/sum ([v (in-hash-values ht/weak)]) v))
-          (+ (for/sum ([k (in-hash-keys fake-ht/immut)]) k)
-             (for/sum ([v (in-hash-values fake-ht/immut)]) v))
-          (+ (for/sum ([k (in-hash-keys fake-ht/mut)]) k)
-             (for/sum ([v (in-hash-values fake-ht/mut)]) v))
-          (+ (for/sum ([k (in-hash-keys fake-ht/weak)]) k)
-             (for/sum ([v (in-hash-values fake-ht/weak)]) v))
-          (+ (for/sum ([k ht/immut-keys/seq]) k)
-             (for/sum ([v ht/immut-vals/seq]) v))
-          (+ (for/sum ([k ht/mut-keys/seq]) k)
-             (for/sum ([v ht/mut-vals/seq]) v))
-          (+ (for/sum ([k ht/weak-keys/seq]) k)
-             (for/sum ([v ht/weak-vals/seq]) v)))
-    
-    (test #t
-          =
-          (for/sum ([(k v) (in-hash ht/immut)]) k)
-          (for/sum ([(k v) (in-hash ht/mut)]) k)
-          (for/sum ([(k v) (in-hash ht/weak)]) k)
-          (for/sum ([(k v) (in-hash fake-ht/immut)]) k)
-          (for/sum ([(k v) (in-hash fake-ht/mut)]) k)
-          (for/sum ([(k v) (in-hash fake-ht/weak)]) k)
-          (for/sum ([(k v) ht/immut/seq]) k)
-          (for/sum ([(k v) ht/mut/seq]) k)
-          (for/sum ([(k v) ht/weak/seq]) k)
-          (for/sum ([k+v (in-hash-pairs ht/immut)]) (car k+v))
-          (for/sum ([k+v (in-hash-pairs ht/mut)]) (car k+v))
-          (for/sum ([k+v (in-hash-pairs ht/weak)]) (car k+v))
-          (for/sum ([k+v (in-hash-pairs fake-ht/immut)]) (car k+v))
-          (for/sum ([k+v (in-hash-pairs fake-ht/mut)]) (car k+v))
-          (for/sum ([k+v (in-hash-pairs fake-ht/weak)]) (car k+v))
-          (for/sum ([k+v ht/immut-pair/seq]) (car k+v))
-          (for/sum ([k+v ht/mut-pair/seq]) (car k+v))
-          (for/sum ([k+v ht/weak-pair/seq]) (car k+v))
-          (for/sum ([k (in-hash-keys ht/immut)]) k)
-          (for/sum ([k (in-hash-keys ht/mut)]) k)
-          (for/sum ([k (in-hash-keys ht/weak)]) k)
-          (for/sum ([k (in-hash-keys fake-ht/immut)]) k)
-          (for/sum ([k (in-hash-keys fake-ht/mut)]) k)
-          (for/sum ([k (in-hash-keys fake-ht/weak)]) k)
-          (for/sum ([k ht/immut-keys/seq]) k)
-          (for/sum ([k ht/mut-keys/seq]) k)
-          (for/sum ([k ht/weak-keys/seq]) k))
-    
-    (test #t
-          =
-          (for/sum ([(k v) (in-hash ht/immut)]) v)
-          (for/sum ([(k v) (in-hash ht/mut)]) v)
-          (for/sum ([(k v) (in-hash ht/weak)]) v)
-          (for/sum ([(k v) (in-hash fake-ht/immut)]) v)
-          (for/sum ([(k v) (in-hash fake-ht/mut)]) v)
-          (for/sum ([(k v) (in-hash fake-ht/weak)]) v)
-          (for/sum ([(k v) ht/immut/seq]) v)
-          (for/sum ([(k v) ht/mut/seq]) v)
-          (for/sum ([(k v) ht/weak/seq]) v)
-          (for/sum ([k+v (in-hash-pairs ht/immut)]) (cdr k+v))
-          (for/sum ([k+v (in-hash-pairs ht/mut)]) (cdr k+v))
-          (for/sum ([k+v (in-hash-pairs ht/weak)]) (cdr k+v))
-          (for/sum ([k+v (in-hash-pairs fake-ht/immut)]) (cdr k+v))
-          (for/sum ([k+v (in-hash-pairs fake-ht/mut)]) (cdr k+v))
-          (for/sum ([k+v (in-hash-pairs fake-ht/weak)]) (cdr k+v))
-          (for/sum ([k+v ht/immut-pair/seq]) (cdr k+v))
-          (for/sum ([k+v ht/mut-pair/seq]) (cdr k+v))
-          (for/sum ([k+v ht/weak-pair/seq]) (cdr k+v))
-          (for/sum ([v (in-hash-values ht/immut)]) v)
-          (for/sum ([v (in-hash-values ht/mut)]) v)
-          (for/sum ([v (in-hash-values ht/weak)]) v)
-          (for/sum ([v (in-hash-values fake-ht/immut)]) v)
-          (for/sum ([v (in-hash-values fake-ht/mut)]) v)
-          (for/sum ([v (in-hash-values fake-ht/weak)]) v)
-          (for/sum ([v ht/immut-vals/seq]) v)
-          (for/sum ([v ht/mut-vals/seq]) v)
-          (for/sum ([v ht/weak-vals/seq]) v)))
+          (test #t =
+           (for/sum ([(k v) (-in-immut-hash ht/immut)]) v)
+           (for/sum ([(k v) (-in-mut-hash ht/mut)]) v)
+           (for/sum ([(k v) (-in-weak-hash ht/weak)]) v)
+           (for/sum ([(k v) (-in-immut-hash fake-ht/immut)]) v)
+           (for/sum ([(k v) (-in-mut-hash fake-ht/mut)]) v)
+           (for/sum ([(k v) (-in-weak-hash fake-ht/weak)]) v)
+           (for/sum ([(k v) ht/immut/seq]) v)
+           (for/sum ([(k v) ht/mut/seq]) v)
+           (for/sum ([(k v) ht/weak/seq]) v)
+           (for/sum ([k+v (-in-immut-hash-pairs ht/immut)]) (cdr k+v))
+           (for/sum ([k+v (-in-mut-hash-pairs ht/mut)]) (cdr k+v))
+           (for/sum ([k+v (-in-weak-hash-pairs ht/weak)]) (cdr k+v))
+           (for/sum ([k+v (-in-immut-hash-pairs fake-ht/immut)]) (cdr k+v))
+           (for/sum ([k+v (-in-mut-hash-pairs fake-ht/mut)]) (cdr k+v))
+           (for/sum ([k+v (-in-weak-hash-pairs fake-ht/weak)]) (cdr k+v))
+           (for/sum ([k+v ht/immut-pair/seq]) (cdr k+v))
+           (for/sum ([k+v ht/mut-pair/seq]) (cdr k+v))
+           (for/sum ([k+v ht/weak-pair/seq]) (cdr k+v))
+           (for/sum ([v (-in-immut-hash-values ht/immut)]) v)
+           (for/sum ([v (-in-mut-hash-values ht/mut)]) v)
+           (for/sum ([v (-in-weak-hash-values ht/weak)]) v)
+           (for/sum ([v (-in-immut-hash-values fake-ht/immut)]) v)
+           (for/sum ([v (-in-mut-hash-values fake-ht/mut)]) v)
+           (for/sum ([v (-in-weak-hash-values fake-ht/weak)]) v)
+           (for/sum ([v ht/immut-vals/seq]) v)
+           (for/sum ([v ht/mut-vals/seq]) v)
+           (for/sum ([v ht/weak-vals/seq]) v))))]))
+  (define-hash-iterations-tester generic
+    in-hash in-hash-pairs in-hash-keys in-hash-values)
+  (define-hash-iterations-tester specific
+    in-immutable-hash in-mutable-hash in-weak-hash
+    in-immutable-hash-pairs in-mutable-hash-pairs in-weak-hash-pairs
+    in-immutable-hash-keys in-mutable-hash-keys in-weak-hash-keys
+    in-immutable-hash-values in-mutable-hash-values in-weak-hash-values)
   
   (define lst1 (build-list 10 values))
   (define lst2 (build-list 10 add1))
-  (test-hash-iterations lst1 lst2)
+  (test-hash-iters-generic lst1 lst2)
+  (test-hash-iters-specific lst1 lst2)
   (define lst3 (build-list 100000 values))
   (define lst4 (build-list 100000 add1))
-  (test-hash-iterations lst3 lst4))
+  (test-hash-iters-generic lst3 lst4)
+  (test-hash-iters-specific lst3 lst4))
 
 ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;