From 23c2cff1ce593a94fae422d6c3c77d971bf2baa5 Mon Sep 17 00:00:00 2001 From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com> Date: Fri, 6 Dec 2024 00:31:46 +0000 Subject: [PATCH 01/10] Fix 13 occurrences of `tidy-require` Keep imports in `require` sorted and grouped by phase, with collections before files. --- .../typed-racket/optimizer/sequence.rkt | 14 ++++---- .../static-contracts/combinators/derived.rkt | 13 +++++-- .../static-contracts/instantiate.rkt | 36 +++++++++---------- .../static-contracts/terminal.rkt | 12 +++---- typed-racket-more/typed/racket/gui.rkt | 4 +-- .../succeed/check-env-lang-based-env.rkt | 4 +-- typed-racket-test/succeed/hash-contract.rkt | 4 +-- .../succeed/opaque-object-name.rkt | 5 +-- typed-racket-test/succeed/pr14829.rkt | 4 +-- .../succeed/pr575-variation-3.rkt | 4 ++- typed-racket-test/succeed/tr-evt.rkt | 6 ++-- .../succeed/type-printer-single-level.rkt | 4 +-- typed-racket-test/succeed/vector-contract.rkt | 4 +-- 13 files changed, 62 insertions(+), 52 deletions(-) diff --git a/typed-racket-lib/typed-racket/optimizer/sequence.rkt b/typed-racket-lib/typed-racket/optimizer/sequence.rkt index 5ab6bf0d2..d47ba3065 100644 --- a/typed-racket-lib/typed-racket/optimizer/sequence.rkt +++ b/typed-racket-lib/typed-racket/optimizer/sequence.rkt @@ -1,16 +1,18 @@ #lang racket/base -(require syntax/parse - racket/match +(require (for-template racket/base + racket/unsafe/ops) racket/function + racket/match + syntax/parse syntax/parse/experimental/specialize - (for-template racket/base racket/unsafe/ops) - "../utils/utils.rkt" "../utils/tc-utils.rkt" "../rep/type-rep.rkt" "../types/abbrev.rkt" - "utils.rkt" + "../utils/tc-utils.rkt" + "../utils/utils.rkt" + "float.rkt" "logging.rkt" - "float.rkt") + "utils.rkt") (provide sequence-opt-expr) diff --git a/typed-racket-lib/typed-racket/static-contracts/combinators/derived.rkt b/typed-racket-lib/typed-racket/static-contracts/combinators/derived.rkt index b6d27b667..ce0b1169c 100644 --- a/typed-racket-lib/typed-racket/static-contracts/combinators/derived.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/combinators/derived.rkt @@ -4,9 +4,16 @@ ;; These are used during optimizations as simplifications. ;; Ex: (listof/sc any/sc) => list?/sc -(require "simple.rkt" "structural.rkt" - (for-template racket/base racket/list racket/set racket/promise - racket/class racket/unit racket/async-channel racket/future)) +(require (for-template racket/async-channel + racket/base + racket/class + racket/future + racket/list + racket/promise + racket/set + racket/unit) + "simple.rkt" + "structural.rkt") (provide (all-defined-out)) (define identifier?/sc (flat/sc #'identifier?)) diff --git a/typed-racket-lib/typed-racket/static-contracts/instantiate.rkt b/typed-racket-lib/typed-racket/static-contracts/instantiate.rkt index 9c34ac617..1300246b7 100644 --- a/typed-racket-lib/typed-racket/static-contracts/instantiate.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/instantiate.rkt @@ -2,24 +2,24 @@ ;; Provides functionality to take a static contract and turn it into a regular contract. -(require - "../utils/utils.rkt" - racket/match - racket/list - racket/contract - racket/syntax - syntax/private/id-table - (for-template racket/base racket/contract) - "combinators.rkt" - "combinators/name.rkt" - "combinators/case-lambda.rkt" - "combinators/parametric.rkt" - "kinds.rkt" - "optimize.rkt" - "parametric-check.rkt" - "structures.rkt" - "constraints.rkt" - "equations.rkt") +(require (for-template racket/base + racket/contract) + racket/contract + racket/list + racket/match + racket/syntax + syntax/private/id-table + "../utils/utils.rkt" + "combinators.rkt" + "combinators/case-lambda.rkt" + "combinators/name.rkt" + "combinators/parametric.rkt" + "constraints.rkt" + "equations.rkt" + "kinds.rkt" + "optimize.rkt" + "parametric-check.rkt" + "structures.rkt") (provide static-contract-may-contain-free-ids?) diff --git a/typed-racket-lib/typed-racket/static-contracts/terminal.rkt b/typed-racket-lib/typed-racket/static-contracts/terminal.rkt index ce224d5bf..37f19885d 100644 --- a/typed-racket-lib/typed-racket/static-contracts/terminal.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/terminal.rkt @@ -3,13 +3,11 @@ ;; Utilities for defining static contracts that have internal structure but have no sub static ;; contracts. Example: (length/sc 1). -(require - "structures.rkt" - "constraints.rkt" - racket/match - (for-syntax - racket/base - syntax/parse)) +(require (for-syntax racket/base + syntax/parse) + racket/match + "constraints.rkt" + "structures.rkt") (provide define-terminal-sc) diff --git a/typed-racket-more/typed/racket/gui.rkt b/typed-racket-more/typed/racket/gui.rkt index 5316ec614..a230b5828 100644 --- a/typed-racket-more/typed/racket/gui.rkt +++ b/typed-racket-more/typed/racket/gui.rkt @@ -2,8 +2,8 @@ ;; Defines a language analogous to #lang racket/gui but typed -(require "gui/base.rkt" - typed/racket) +(require typed/racket + "gui/base.rkt") (provide (all-from-out "gui/base.rkt") (all-from-out typed/racket)) diff --git a/typed-racket-test/succeed/check-env-lang-based-env.rkt b/typed-racket-test/succeed/check-env-lang-based-env.rkt index 0002e6e7c..67435c04f 100644 --- a/typed-racket-test/succeed/check-env-lang-based-env.rkt +++ b/typed-racket-test/succeed/check-env-lang-based-env.rkt @@ -1,6 +1,6 @@ #lang racket -(require (only-in typed-racket/base-env/base-env [org-map be:org-map]) - syntax/srcloc +(require syntax/srcloc + (only-in typed-racket/base-env/base-env [org-map be:org-map]) (only-in typed-racket/base-env/base-env-numeric [org-map ben:org-map])) (for ([a (in-list (append be:org-map diff --git a/typed-racket-test/succeed/hash-contract.rkt b/typed-racket-test/succeed/hash-contract.rkt index 9b5928dc7..d782570ae 100644 --- a/typed-racket-test/succeed/hash-contract.rkt +++ b/typed-racket-test/succeed/hash-contract.rkt @@ -5,8 +5,8 @@ ;; 2. don't overlap in an or/c (module+ test - (require rackunit - racket/contract + (require racket/contract + rackunit typed-racket/utils/hash-contract) (test-case "hash-contract:correct" diff --git a/typed-racket-test/succeed/opaque-object-name.rkt b/typed-racket-test/succeed/opaque-object-name.rkt index bb2b7f471..8f351244e 100644 --- a/typed-racket-test/succeed/opaque-object-name.rkt +++ b/typed-racket-test/succeed/opaque-object-name.rkt @@ -1,6 +1,7 @@ #lang racket -(require typed-racket/utils/opaque-object rackunit - (for-syntax (only-in syntax/srcloc build-source-location-list))) +(require (for-syntax (only-in syntax/srcloc build-source-location-list)) + rackunit + typed-racket/utils/opaque-object) ;; -------------------------------------------------------------------------------------------------- diff --git a/typed-racket-test/succeed/pr14829.rkt b/typed-racket-test/succeed/pr14829.rkt index d856f5d77..51bbe9ce6 100644 --- a/typed-racket-test/succeed/pr14829.rkt +++ b/typed-racket-test/succeed/pr14829.rkt @@ -3,8 +3,8 @@ ;; Test for PR 14829. Make sure the type is not printed ;; for expressions that return Bottom. -(require rackunit - racket/sandbox) +(require racket/sandbox + rackunit) (define out (open-output-string)) diff --git a/typed-racket-test/succeed/pr575-variation-3.rkt b/typed-racket-test/succeed/pr575-variation-3.rkt index 1149d2772..af5c8cca6 100644 --- a/typed-racket-test/succeed/pr575-variation-3.rkt +++ b/typed-racket-test/succeed/pr575-variation-3.rkt @@ -1,5 +1,7 @@ #lang racket/base -(require rackunit (for-syntax rackunit racket/base)) +(require (for-syntax racket/base + rackunit) + rackunit) ;; Coerce vectors to/from syntax objects, check mutability diff --git a/typed-racket-test/succeed/tr-evt.rkt b/typed-racket-test/succeed/tr-evt.rkt index b0b43bc9a..0bf8041f4 100644 --- a/typed-racket-test/succeed/tr-evt.rkt +++ b/typed-racket-test/succeed/tr-evt.rkt @@ -1,8 +1,8 @@ #lang racket/base -(require rackunit - typed-racket/utils/evt-contract - racket/contract) +(require racket/contract + rackunit + typed-racket/utils/evt-contract) (check-true (contract-stronger? (tr:evt/c ( Date: Fri, 6 Dec 2024 00:31:46 +0000 Subject: [PATCH 02/10] Fix 19 occurrences of `single-clause-match-to-match-define` This `match` expression can be simplified using `match-define`. --- .../static-contracts/combinators/exist.rkt | 17 ++-- .../combinators/parametric.rkt | 44 ++++----- .../static-contracts/constraints.rkt | 90 +++++++++---------- .../static-contracts/instantiate.rkt | 14 +-- .../static-contracts/structures.rkt | 14 ++- 5 files changed, 81 insertions(+), 98 deletions(-) diff --git a/typed-racket-lib/typed-racket/static-contracts/combinators/exist.rkt b/typed-racket-lib/typed-racket/static-contracts/combinators/exist.rkt index 9d92dbb74..394f83ad5 100644 --- a/typed-racket-lib/typed-racket/static-contracts/combinators/exist.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/combinators/exist.rkt @@ -27,16 +27,13 @@ (f rngs 'invariant) (void)) (define (sc->contract v f) - (match v - [(exist-combinator (list names doms rngs)) - (parameterize ([static-contract-may-contain-free-ids? #t]) - (let ([a (with-syntax ([doms-stx (f doms)] - [rngs-stx (f rngs)] - [n (car names)]) - #'(->i ([n doms-stx]) - (_ (n) - rngs-stx)))]) - a))])) + (match-define (exist-combinator (list names doms rngs)) v) + (parameterize ([static-contract-may-contain-free-ids? #t]) + (let ([a (with-syntax ([doms-stx (f doms)] + [rngs-stx (f rngs)] + [n (car names)]) + #'(->i ([n doms-stx]) (_ (n) rngs-stx)))]) + a))) (define (sc->constraints v f) (simple-contract-restrict 'flat))]) diff --git a/typed-racket-lib/typed-racket/static-contracts/combinators/parametric.rkt b/typed-racket-lib/typed-racket/static-contracts/combinators/parametric.rkt index bfc8c98e1..605b5524e 100644 --- a/typed-racket-lib/typed-racket/static-contracts/combinators/parametric.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/combinators/parametric.rkt @@ -35,22 +35,18 @@ #:property prop:combinator-name "parametric->/sc" #:methods gen:sc [(define (sc-map v f) - (match v - [(parametric-combinator (list arg) vars) - (parametric-combinator (list (f arg 'covariant)) vars)])) + (match-define (parametric-combinator (list arg) vars) v) + (parametric-combinator (list (f arg 'covariant)) vars)) (define (sc-traverse v f) - (match v - [(parametric-combinator (list arg) vars) - (f arg 'covariant) - (void)])) + (match-define (parametric-combinator (list arg) vars) v) + (f arg 'covariant) + (void)) (define (sc->contract v f) - (match v - [(parametric-combinator (list arg) vars) - #`(parametric->/c #,vars #,(f arg))])) + (match-define (parametric-combinator (list arg) vars) v) + #`(parametric->/c #,vars #,(f arg))) (define (sc->constraints v f) - (match v - [(parametric-combinator (list arg) vars) - (merge-restricts* 'impersonator (list (f arg)))]))]) + (match-define (parametric-combinator (list arg) vars) v) + (merge-restricts* 'impersonator (list (f arg))))]) (define (parametric->/sc vars body) (parametric-combinator (list body) vars)) @@ -70,22 +66,18 @@ #:property prop:combinator-name "sealing->/sc" #:methods gen:sc [(define (sc-map v f) - (match v - [(sealing-combinator (list arg) vars members) - (sealing-combinator (list (f arg 'covariant)) vars members)])) + (match-define (sealing-combinator (list arg) vars members) v) + (sealing-combinator (list (f arg 'covariant)) vars members)) (define (sc-traverse v f) - (match v - [(sealing-combinator (list arg) vars members) - (f arg 'covariant) - (void)])) + (match-define (sealing-combinator (list arg) vars members) v) + (f arg 'covariant) + (void)) (define (sc->contract v f) - (match v - [(sealing-combinator (list arg) vars members) - #`(sealing->/c #,(car vars) #,members #,(f arg))])) + (match-define (sealing-combinator (list arg) vars members) v) + #`(sealing->/c #,(car vars) #,members #,(f arg))) (define (sc->constraints v f) - (match v - [(sealing-combinator (list arg) vars members) - (merge-restricts* 'impersonator (list (f arg)))]))]) + (match-define (sealing-combinator (list arg) vars members) v) + (merge-restricts* 'impersonator (list (f arg))))]) (define (sealing->/sc vars members body) (sealing-combinator (list body) vars members)) diff --git a/typed-racket-lib/typed-racket/static-contracts/constraints.rkt b/typed-racket-lib/typed-racket/static-contracts/constraints.rkt index 6a47157e9..d56dc6208 100644 --- a/typed-racket-lib/typed-racket/static-contracts/constraints.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/constraints.rkt @@ -182,32 +182,28 @@ (define (add-constraint cr max) - (match cr - [(contract-restrict v rec constraints) - (define con (constraint v max)) - (if (trivial-constraint? con) - cr - (contract-restrict v rec (set-add constraints con)))])) + (match-define (contract-restrict v rec constraints) cr) + (define con (constraint v max)) + (if (trivial-constraint? con) + cr + (contract-restrict v rec (set-add constraints con)))) -(define (add-recursive-values cr dict) - (match cr - [(contract-restrict v rec constraints) - (contract-restrict v (free-id-table-union (list rec dict)) constraints)])) +(define (add-recursive-values cr dict) + (match-define (contract-restrict v rec constraints) cr) + (contract-restrict v (free-id-table-union (list rec dict)) constraints)) (define (merge-restricts* min crs) (apply merge-restricts min crs)) (define (merge-restricts min . crs) - (match crs - [(list (contract-restrict vs rec constraints) ...) - (contract-restrict (merge-kind-maxes min vs) - (free-id-table-union rec) - (apply set-union (set) constraints))])) + (match-define (list (contract-restrict vs rec constraints) ...) crs) + (contract-restrict (merge-kind-maxes min vs) + (free-id-table-union rec) + (apply set-union (set) constraints))) (define (merge-kind-maxes min-kind vs) - (match vs - [(list (kind-max variables maxes) ...) - (kind-max (free-id-set-union variables) (apply combine-kinds min-kind maxes))])) + (match-define (list (kind-max variables maxes) ...) vs) + (kind-max (free-id-set-union variables) (apply combine-kinds min-kind maxes))) (define (close-loop names crs body) (define eqs (make-equation-set)) @@ -222,38 +218,36 @@ (define (instantiate-cr cr lookup-id) (define (instantiate-kind-max km) - (match km - [(kind-max ids actual) - (define-values (bvals unbound-ids) - (for/fold ([bvals '()] [ubids (make-immutable-free-id-table)]) - ([(id _) (in-free-id-table ids)]) - (if (member id names) - (values (cons (contract-restrict-value (lookup-id id)) bvals) ubids) - (values bvals (free-id-table-set ubids id #t))))) - (merge-kind-maxes 'flat (cons (kind-max unbound-ids actual) bvals))])) + (match-define (kind-max ids actual) km) + (define-values (bvals unbound-ids) + (for/fold ([bvals '()] + [ubids (make-immutable-free-id-table)]) + ([(id _) (in-free-id-table ids)]) + (if (member id names) + (values (cons (contract-restrict-value (lookup-id id)) bvals) ubids) + (values bvals (free-id-table-set ubids id #t))))) + (merge-kind-maxes 'flat (cons (kind-max unbound-ids actual) bvals))) (define (instantiate-constraint con) - (match con - [(constraint km bound) - (constraint (instantiate-kind-max km) bound)])) - - (match cr - [(contract-restrict (kind-max ids max) rec constraints) - (define-values (bound-vals unbound-ids) - (for/fold ([bvs '()] [ubids (make-immutable-free-id-table)]) - ([(id _) (in-free-id-table ids)]) - (if (member id names) - (values (cons (lookup-id id) bvs) ubids) - (values bvs (free-id-table-set ubids id #t))))) - (merge-restricts* 'flat (cons - (contract-restrict - (kind-max unbound-ids max) - rec - (for*/set ([c (in-immutable-set constraints)] - [ic (in-value (instantiate-constraint c))] - #:when (not (trivial-constraint? ic))) - ic)) - bound-vals))])) + (match-define (constraint km bound) con) + (constraint (instantiate-kind-max km) bound)) + + (match-define (contract-restrict (kind-max ids max) rec constraints) cr) + (define-values (bound-vals unbound-ids) + (for/fold ([bvs '()] + [ubids (make-immutable-free-id-table)]) + ([(id _) (in-free-id-table ids)]) + (if (member id names) + (values (cons (lookup-id id) bvs) ubids) + (values bvs (free-id-table-set ubids id #t))))) + (merge-restricts* 'flat + (cons (contract-restrict (kind-max unbound-ids max) + rec + (for*/set ([c (in-immutable-set constraints)] + [ic (in-value (instantiate-constraint c))] + #:when (not (trivial-constraint? ic))) + ic)) + bound-vals))) (for ([name (in-list names)] [cr (in-list crs)]) diff --git a/typed-racket-lib/typed-racket/static-contracts/instantiate.rkt b/typed-racket-lib/typed-racket/static-contracts/instantiate.rkt index 1300246b7..fd968ef07 100644 --- a/typed-racket-lib/typed-racket/static-contracts/instantiate.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/instantiate.rkt @@ -145,12 +145,14 @@ (variable-ref (hash-ref vars id))) (for ([(name v) (in-free-id-table recursives)]) - (match v - [(kind-max others max) - (add-equation! eqs - (hash-ref vars name) - (λ () (apply combine-kinds max (for/list ([(id _) (in-free-id-table others)]) - (lookup id)))))])) + (match-define (kind-max others max) v) + (add-equation! eqs + (hash-ref vars name) + (λ () + (apply combine-kinds + max + (for/list ([(id _) (in-free-id-table others)]) + (lookup id)))))) (define var-values (resolve-equations eqs)) (for/hash ([(name var) (in-hash vars)]) (values name (hash-ref var-values var)))) diff --git a/typed-racket-lib/typed-racket/static-contracts/structures.rkt b/typed-racket-lib/typed-racket/static-contracts/structures.rkt index e1a15e6af..5c433a4e8 100644 --- a/typed-racket-lib/typed-racket/static-contracts/structures.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/structures.rkt @@ -124,15 +124,13 @@ #:transparent #:methods gen:sc [(define (sc-map v f) - (match v - [(recursive-sc names values body) - (recursive-sc names (map (λ (v) (f v 'covariant)) values) (f body 'covariant))])) + (match-define (recursive-sc names values body) v) + (recursive-sc names (map (λ (v) (f v 'covariant)) values) (f body 'covariant))) (define (sc-traverse v f) - (match v - [(recursive-sc names values body) - (for-each (λ (v) (f v 'covariant)) values) - (f body 'covariant) - (void)])) + (match-define (recursive-sc names values body) v) + (for-each (λ (v) (f v 'covariant)) values) + (f body 'covariant) + (void)) (define (sc->constraints v f) (simple-contract-restrict 'impersonator))] #:methods gen:custom-write [(define write-proc recursive-sc-write-proc)]) From 9ae3a40644cadda1a25e601d365baa66f056c9e1 Mon Sep 17 00:00:00 2001 From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com> Date: Fri, 6 Dec 2024 00:31:46 +0000 Subject: [PATCH 03/10] Fix 1 occurrence of `define-values-values-to-define` This use of `define-values` is unnecessary. --- .../typed-racket/static-contracts/combinators/name.rkt | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/typed-racket-lib/typed-racket/static-contracts/combinators/name.rkt b/typed-racket-lib/typed-racket/static-contracts/combinators/name.rkt index 449c068a6..e2c1c5fff 100644 --- a/typed-racket-lib/typed-racket/static-contracts/combinators/name.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/combinators/name.rkt @@ -76,10 +76,9 @@ [else (raise-argument-error 'lookup-name-sc "side?" typed-side)]))) (define (register-name-sc type typed-thunk untyped-thunk both-thunk) - (define-values (typed-name untyped-name both-name) - (values (generate-temporary) - (generate-temporary) - (generate-temporary))) + (define typed-name (generate-temporary)) + (define untyped-name (generate-temporary)) + (define both-name (generate-temporary)) (hash-set! (name-sc-table) type (list (name-combinator null typed-name) From c304799435d2129b5c490e32c06cfed18c7db404 Mon Sep 17 00:00:00 2001 From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com> Date: Fri, 6 Dec 2024 00:31:46 +0000 Subject: [PATCH 04/10] Fix 1 occurrence of `let-to-define` Internal definitions are recommended instead of `let` expressions, to reduce nesting. --- .../succeed/opaque-object-stronger.rkt | 23 ++++++++----------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/typed-racket-test/succeed/opaque-object-stronger.rkt b/typed-racket-test/succeed/opaque-object-stronger.rkt index 6fbcb23e5..1b4808074 100644 --- a/typed-racket-test/succeed/opaque-object-stronger.rkt +++ b/typed-racket-test/succeed/opaque-object-stronger.rkt @@ -140,19 +140,16 @@ (m1 (->m any/c integer?)) (m2 (->m any/c (listof any/c))))) - (let ([ctc-stronger - (object/c-opaque - (a (->m symbol?)) - (b (->m (between/c 2 3))) - (c (->m any/c (listof (char-in #\A #\B)))))] - [ctc-weaker - (object/c-opaque - (a (->m symbol?)) - (b (->m (between/c 0 5))) - (c (->m any/c (listof (char-in #\A #\Z)))))]) - (test-stronger? ctc-stronger ctc-weaker) - (test-not-equivalent? ctc-stronger ctc-weaker)) -) + (define ctc-stronger + (object/c-opaque (a (->m symbol?)) + (b (->m (between/c 2 3))) + (c (->m any/c (listof (char-in #\A #\B)))))) + (define ctc-weaker + (object/c-opaque (a (->m symbol?)) + (b (->m (between/c 0 5))) + (c (->m any/c (listof (char-in #\A #\Z)))))) + (test-stronger? ctc-stronger ctc-weaker) + (test-not-equivalent? ctc-stronger ctc-weaker)) (let () ;; vs. object/c (test-stronger? From ac6e7a151bcbecc432477227ea4da2fe0fc8dd03 Mon Sep 17 00:00:00 2001 From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com> Date: Fri, 6 Dec 2024 00:31:46 +0000 Subject: [PATCH 05/10] Fix 1 occurrence of `sort-with-keyed-comparator-to-sort-by-key` This `sort` expression can be replaced with a simpler, equivalent expression. --- typed-racket-lib/typed-racket/static-contracts/optimize.rkt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/typed-racket-lib/typed-racket/static-contracts/optimize.rkt b/typed-racket-lib/typed-racket/static-contracts/optimize.rkt index d2b2574ea..e6372b3d2 100644 --- a/typed-racket-lib/typed-racket/static-contracts/optimize.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/optimize.rkt @@ -111,7 +111,7 @@ ;; All results must have the same range (unless (equal? (set-count (list->set ranges)) 1) (fail)) - (define sorted-args (sort args (λ (l1 l2) (< (length l1) (length l2))))) + (define sorted-args (sort args < #:key length)) (define shortest-args (first sorted-args)) (define longest-args (last sorted-args)) ;; The number of arguments must increase by 1 with no gaps From b4c3e88d7dc5104898027508e386da377a7e56ea Mon Sep 17 00:00:00 2001 From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com> Date: Fri, 6 Dec 2024 00:31:46 +0000 Subject: [PATCH 06/10] Fix 1 occurrence of `nested-for-to-for*` These nested `for` loops can be replaced by a single `for*` loop. --- .../typed-racket/static-contracts/optimize.rkt | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/typed-racket-lib/typed-racket/static-contracts/optimize.rkt b/typed-racket-lib/typed-racket/static-contracts/optimize.rkt index e6372b3d2..0de66c6be 100644 --- a/typed-racket-lib/typed-racket/static-contracts/optimize.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/optimize.rkt @@ -341,11 +341,11 @@ (let loop ((to-look-at reachable)) (unless (zero? (free-id-table-count to-look-at)) (define new-table (make-free-id-table)) - (for ([(id _) (in-free-id-table to-look-at)]) - (for ([(id _) (in-free-id-table (free-id-table-ref main-table id))]) - (unless (free-id-table-ref seen id #f) - (free-id-table-set! seen id #t) - (free-id-table-set! new-table id #t)))) + (for* ([(id _) (in-free-id-table to-look-at)] + [(id _) (in-free-id-table (free-id-table-ref main-table id))]) + (unless (free-id-table-ref seen id #f) + (free-id-table-set! seen id #t) + (free-id-table-set! new-table id #t))) (loop new-table))) ;; Determine if the recursive name is referenced in the static contract From 532b4af0348413d1d90356b4bac7f249c52aaeee Mon Sep 17 00:00:00 2001 From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com> Date: Fri, 6 Dec 2024 00:31:46 +0000 Subject: [PATCH 07/10] Fix 1 occurrence of `define-let-to-double-define` This `let` expression can be pulled up into a `define` expression. --- typed-racket-lib/typed-racket/static-contracts/optimize.rkt | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/typed-racket-lib/typed-racket/static-contracts/optimize.rkt b/typed-racket-lib/typed-racket/static-contracts/optimize.rkt index 0de66c6be..3870a1f2c 100644 --- a/typed-racket-lib/typed-racket/static-contracts/optimize.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/optimize.rkt @@ -403,9 +403,8 @@ ;; 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 flat-sc? - (let ([sc->kind (make-sc->kind recursive-kinds)]) - (λ (sc) (eq? 'flat (sc->kind sc))))) + (define sc->kind (make-sc->kind recursive-kinds)) + (define flat-sc? (λ (sc) (eq? 'flat (sc->kind sc)))) (define trusted-side-reduce (make-trusted-side-reduce flat-sc?)) (define update-side (make-update-side flat-sc?)) From 6920f85ef30f2fc6d34d7efe8726fc9ce8394ba1 Mon Sep 17 00:00:00 2001 From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com> Date: Fri, 6 Dec 2024 00:31:46 +0000 Subject: [PATCH 08/10] Fix 1 occurrence of `unless-expression-in-for-loop-to-unless-keyword` Use the `#:unless` keyword instead of `unless` to reduce loop body indentation. --- .../typed-racket/static-contracts/optimize.rkt | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/typed-racket-lib/typed-racket/static-contracts/optimize.rkt b/typed-racket-lib/typed-racket/static-contracts/optimize.rkt index 3870a1f2c..3d623ade7 100644 --- a/typed-racket-lib/typed-racket/static-contracts/optimize.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/optimize.rkt @@ -342,10 +342,10 @@ (unless (zero? (free-id-table-count to-look-at)) (define new-table (make-free-id-table)) (for* ([(id _) (in-free-id-table to-look-at)] - [(id _) (in-free-id-table (free-id-table-ref main-table id))]) - (unless (free-id-table-ref seen id #f) - (free-id-table-set! seen id #t) - (free-id-table-set! new-table id #t))) + [(id _) (in-free-id-table (free-id-table-ref main-table id))] + #:unless (free-id-table-ref seen id #f)) + (free-id-table-set! seen id #t) + (free-id-table-set! new-table id #t)) (loop new-table))) ;; Determine if the recursive name is referenced in the static contract From c06f7a0dc1eb1e0f31c04e68ef8c4216125d2fe6 Mon Sep 17 00:00:00 2001 From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com> Date: Fri, 6 Dec 2024 00:31:46 +0000 Subject: [PATCH 09/10] Fix 1 occurrence of `define-lambda-to-define` The `define` form supports a shorthand for defining functions. --- typed-racket-lib/typed-racket/static-contracts/optimize.rkt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/typed-racket-lib/typed-racket/static-contracts/optimize.rkt b/typed-racket-lib/typed-racket/static-contracts/optimize.rkt index 3d623ade7..4db981d6b 100644 --- a/typed-racket-lib/typed-racket/static-contracts/optimize.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/optimize.rkt @@ -404,7 +404,8 @@ ;; 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 (make-sc->kind recursive-kinds)) - (define flat-sc? (λ (sc) (eq? 'flat (sc->kind sc)))) + (define (flat-sc? sc) + (eq? 'flat (sc->kind sc))) (define trusted-side-reduce (make-trusted-side-reduce flat-sc?)) (define update-side (make-update-side flat-sc?)) From 1e6431932ce8d1c1979d683514d2f0318a9c64b5 Mon Sep 17 00:00:00 2001 From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com> Date: Fri, 6 Dec 2024 00:31:46 +0000 Subject: [PATCH 10/10] Fix 1 occurrence of `let-to-define` Internal definitions are recommended instead of `let` expressions, to reduce nesting. --- .../static-contracts/combinators/exist.rkt | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/typed-racket-lib/typed-racket/static-contracts/combinators/exist.rkt b/typed-racket-lib/typed-racket/static-contracts/combinators/exist.rkt index 394f83ad5..0f16fc24f 100644 --- a/typed-racket-lib/typed-racket/static-contracts/combinators/exist.rkt +++ b/typed-racket-lib/typed-racket/static-contracts/combinators/exist.rkt @@ -29,11 +29,12 @@ (define (sc->contract v f) (match-define (exist-combinator (list names doms rngs)) v) (parameterize ([static-contract-may-contain-free-ids? #t]) - (let ([a (with-syntax ([doms-stx (f doms)] - [rngs-stx (f rngs)] - [n (car names)]) - #'(->i ([n doms-stx]) (_ (n) rngs-stx)))]) - a))) + (define a + (with-syntax ([doms-stx (f doms)] + [rngs-stx (f rngs)] + [n (car names)]) + #'(->i ([n doms-stx]) (_ (n) rngs-stx)))) + a)) (define (sc->constraints v f) (simple-contract-restrict 'flat))])