Automated Resyntax fixes

typed-racket-lib/typed-racket/rep/prop-rep.rkt

@@ -1,15 +1,15 @@
 #lang racket/base
 
-(require "../utils/utils.rkt"
+(require racket/lazy-require
+         racket/match
          (contract-req)
+         (only-in racket/unsafe/ops unsafe-fx<=)
+         "../utils/utils.rkt"
+         "core-rep.rkt"
          "fme-utils.rkt"
-         "rep-utils.rkt"
          "free-variance.rkt"
-         "core-rep.rkt"
          "object-rep.rkt"
-         racket/match
-         racket/lazy-require
-         (only-in racket/unsafe/ops unsafe-fx<=))
+         "rep-utils.rkt")
 
 (lazy-require
  ["../types/prop-ops.rkt" (-and -or negate-prop)])
@@ -143,8 +143,7 @@
   [#:for-each (f) (for-each f ps)]
   [#:custom-constructor/contract
    (-> (listof (or/c TypeProp? NotTypeProp? LeqProp?)) OrProp?)
-   (let ([ps (sort ps (λ (p q) (unsafe-fx<= (eq-hash-code p)
-                                            (eq-hash-code q))))])
+   (let ([ps (sort ps unsafe-fx<= #:key eq-hash-code)])
      (intern-single-ref!
       orprop-intern-table
       ps

typed-racket-lib/typed-racket/typecheck/tc-app/utils.rkt

@@ -1,8 +1,8 @@
 #lang racket/base
 
-(require syntax/parse
-         syntax/parse/experimental/reflect
-         (for-syntax racket/base syntax/parse))
+(require (for-syntax racket/base syntax/parse)
+         syntax/parse
+         syntax/parse/experimental/reflect)
 
 (provide define-reified-syntax-class define-tc/app-syntax-class)
 

typed-racket-lib/typed-racket/types/match-expanders.rkt

@@ -1,16 +1,16 @@
 #lang racket/base
 
-(require "../utils/utils.rkt"
-         "../rep/type-rep.rkt"
-         "../rep/values-rep.rkt"
-         "../rep/rep-utils.rkt"
+(require (for-syntax racket/base syntax/parse)
          racket/match
-         syntax/parse/define
          racket/set
          racket/unsafe/undefined
-         "resolve.rkt"
+         syntax/parse/define
+         "../rep/rep-utils.rkt"
+         "../rep/type-rep.rkt"
+         "../rep/values-rep.rkt"
+         "../utils/utils.rkt"
          "base-abbrev.rkt"
-         (for-syntax racket/base syntax/parse))
+         "resolve.rkt")
 
 (provide Listof: List: MListof: AnyPoly: AnyPoly-names:
          HashTableTop:
@@ -75,20 +75,19 @@
          (app (λ (t) (Listof? t #t)) (? Type? elem-pat)))])))
 
 
-(define-simple-macro (make-Listof-pred listof-pred?:id pair-matcher:id)
+(define-syntax-parse-rule (make-Listof-pred listof-pred?:id pair-matcher:id)
   (define (listof-pred? t [simple? #f])
     (match t
-      [(Mu-unsafe:
-        (Union: (== -Null)
-                (list (pair-matcher elem-t (B: 0)))))
+      [(Mu-unsafe: (Union: (== -Null) (list (pair-matcher elem-t (B: 0)))))
        (define elem-t* (instantiate-type elem-t t))
        (cond
          [simple? (and (equal? elem-t elem-t*) elem-t)]
          [else elem-t*])]
       [(Union: (== -Null) (list (pair-matcher hd-t tl-t)))
        (cond
          [(listof-pred? tl-t)
-          => (λ (lst-t) (and (equal? hd-t lst-t) hd-t))]
+          =>
+          (λ (lst-t) (and (equal? hd-t lst-t) hd-t))]
          [else #f])]
       [_ #f])))