Automated Resyntax fixes #1449
Automated Resyntax fixes #1449
Conversation
![resyntax-ci[bot]](https://avatars.githubusercontent.com/in/999945?s=60&v=4){kind=small}
Internal definitions are recommended instead of `let` expressions, to reduce nesting.
This `if` expression can be refactored to an equivalent expression using `and`.
This `match` expression can be simplified using `match-define`.
This expression is equivalent to calling the `positive?` predicate.
The `let` expression in this `begin0` form can be extracted into the surrounding definition context.
`cond` with internal definitions is preferred over `if` with `let`, to reduce nesting
This conditional expression can be replaced with a simpler, equivalent expression.
The `define-simple-macro` form has been renamed to `define-syntax-parse-rule`.
This negated `unless` expression can be replaced by a `when` expression.
Internal definitions are recommended instead of `let` expressions, to reduce nesting.
This `for/fold` loop can be simplified by using the `#:when` keyword.
This `let` expression can be pulled up into a `define` expression.
Using `when` and `unless` is simpler than a conditional with an always-throwing branch.
This `map` operation can be replaced with a `for/list` loop.
This `sort` expression can be replaced with a simpler, equivalent expression.
This use of `format` does nothing.
This `for/fold` loop can be simplified by using the `#:when` keyword.
| (let ([dom+ (for/fold ([acc '()]) ([dom (in-list dom*)]) | ||
| (if (pair? dom) | ||
| (cons (cdr dom) acc) | ||
| acc))]) |
There was a problem hiding this comment.
Such a rewrite would have to add a reverse in order to preserve ordering, so Resyntax would rewrite it to this:
(reverse
(for/list ([dom (in-list dom*)]
#:when (pair? dom))
(cdr dom)))I'm not sure that's a great idea since it adds two extra linear traversals over the resulting list, making the code slower.
There was a problem hiding this comment.
We should have a for/reverse, clearly.
There was a problem hiding this comment.
I'm not all that sure it comes up often enough to be warranted :p I think a lot of the time when the order of a list doesn't matter so using for/reverse would be viable, it would also be the case that just using an actually-unordered data structure like a set would be even better.
| (let ([e (syntax-e args)]) | ||
| (values (car e) (cdr e)))] | ||
| (define e (syntax-e args)) | ||
| (values (car e) (cdr e))] |
There was a problem hiding this comment.
There should be a function that does this.
Resyntax fixed 38 issues in 20 files.
single-clause-match-to-match-definelet-to-definefor/fold-with-conditional-body-to-when-keywordcond-let-to-cond-definezero-comparison-to-positive?define-simple-macro-to-define-syntax-parse-ruledefine-let-to-double-definesort-with-keyed-comparator-to-sort-by-keyformat-identityalways-throwing-cond-to-whenmap-to-forif-x-else-x-to-andif-let-to-condinverted-unlessbegin0-let-to-define-begin0if-else-false-to-and