Summary:

There is a very common pattern in the implementation of low-level macros:

    (if something
        (void)
        (raise-syntax-error #f constant-string local-variable))

Introduce the appropriate abstraction to handle them.

This does not introduce uses; rather, uses will be added as more of the core
syntax is centralized and some of the implementations are slightly modernized.
See racket#5406 for more on that effort.

This is quite straightforward; mostly it's just changing a cond where
the first pile of branches do error checking to a handful of
`raise-syntax-error-if` and `raise-syntax-error-unless` invocations.
I also took advantage of the opportunity to improve some error messages,
going from:

    bad syntax
    missing test expression and body
    missing body

to

    bad syntax (illegal use of `.')
    bad syntax (missing test expression and body)
    bad syntax (missing body)

This is part of a larger effort to centralize and modernize some core syntax
constructs; see racket#5406 for more on that.

Quite straightforward. This also improves the error messages from

    bad syntax

to

    bad syntax (illegal use of `.')
    bad syntax (missing identifier and body)
    bad syntax (missing body)

This is part of a larger effort to centralize and modernize some core syntax
constructs; see racket#5406 for more on that.

Minimal modifications to the `cond` implementation to only use kernel
syntax. Note that it still uses non-kernel functions.

This is part of a larger effort to centralize and modernize some core syntax
constructs; see racket#5406 for more on that.

Minimal modifications to the `cond` implementation to only use kernel
syntax. Note that it still uses non-kernel functions.

This is part of a larger effort to centralize and modernize some core syntax
constructs; see racket#5406 for more on that.

There is a very common pattern in the implementation of low-level macros:

    (if something
        (void)
        (raise-syntax-error #f constant-string local-variable))

Introduce the appropriate abstraction to handle them.

This does not introduce uses; rather, uses will be added as more of the core
syntax is centralized and some of the implementations are slightly modernized.
See racket#5406 for more on that effort.

This is quite straightforward; mostly it's just changing a cond where
the first pile of branches do error checking to a handful of
`raise-syntax-error-if` and `raise-syntax-error-unless` invocations.
I also took advantage of the opportunity to improve some error messages,
going from:

    bad syntax
    missing test expression and body
    missing body

to

    bad syntax    [when used as identifier or in improper list]
    bad syntax (missing test expression and body)
    bad syntax (missing body)

This is part of a larger effort to centralize and modernize some core syntax
constructs; see racket#5406 for more on that.

Quite straightforward. This also improves the error messages from

    bad syntax

to

    bad syntax   [when used as identifier macro or in an improper list]
    bad syntax (missing identifier and body)
    bad syntax (missing body)

This is part of a larger effort to centralize and modernize some core syntax
constructs; see racket#5406 for more on that.

Minimal modifications to the `cond` implementation to only use kernel
syntax. Note that it still uses non-kernel functions.

This is part of a larger effort to centralize and modernize some core syntax
constructs; see racket#5406 for more on that.

There is a very common pattern in the implementation of low-level macros:

    (if something
        (void)
        (raise-syntax-error #f constant-string local-variable))

Introduce the appropriate abstraction to handle them.

This does not introduce uses; rather, uses will be added as more of the core
syntax is centralized and some of the implementations are slightly modernized.
See #5406 for more on that effort.

This is quite straightforward; mostly it's just changing a cond where
the first pile of branches do error checking to a handful of
`raise-syntax-error-if` and `raise-syntax-error-unless` invocations.
I also took advantage of the opportunity to improve some error messages,
going from:

    bad syntax
    missing test expression and body
    missing body

to

    bad syntax    [when used as identifier or in improper list]
    bad syntax (missing test expression and body)
    bad syntax (missing body)

This is part of a larger effort to centralize and modernize some core syntax
constructs; see #5406 for more on that.

Quite straightforward. This also improves the error messages from

    bad syntax

to

    bad syntax   [when used as identifier macro or in an improper list]
    bad syntax (missing identifier and body)
    bad syntax (missing body)

This is part of a larger effort to centralize and modernize some core syntax
constructs; see #5406 for more on that.

Minimal modifications to the `cond` implementation to only use kernel
syntax. Note that it still uses non-kernel functions.

This is part of a larger effort to centralize and modernize some core syntax
constructs; see #5406 for more on that.

This rename makes twofold sense. First, `qq-and-or.rkt` is already more
than just what it says on the tin-- it also defines `let`, `let*`, and
`letrec`. Second, as part of the effort to reduce startup time, we plan
on merging more core macros into the same file; for more info about the
overall effort, see racket#5406

Testing: manually reviewed `git grep qq-and-or` in this repo; the only hits
are #%requires which this commit adjusts. Searched all `*.rkt` and `*.ss`
files in my copy of the package archive; the hits are `stxparse-info` which
appears to include a copy of a decent chunk of racket/base's implementation and
is broken anyway, and one hit in TR which will need a coordinated change.

Note that this requires a coordinated (backwards-compatible) change in Typed
Racket which should be merged at least a couple hours before this change is
merged. That's racket/typed-racket#1499

This rename makes twofold sense. First, `qq-and-or.rkt` is already more
than just what it says on the tin-- it also defines `let`, `let*`, and
`letrec`. Second, as part of the effort to reduce startup time, we plan
on merging more core macros into the same file; for more info about the
overall effort, see racket#5406

Testing: manually reviewed `git grep qq-and-or` in this repo; the only hits
are #%requires which this commit adjusts. Searched all `*.rkt` and `*.ss`
files in my copy of the package archive; the hits are `stxparse-info` which
appears to include a copy of a decent chunk of racket/base's implementation and
is broken anyway, and one hit in TR which will need a coordinated change.

Note that this requires a coordinated (backwards-compatible) change in Typed
Racket which should be merged at least a couple hours before this change is
merged. That's racket/typed-racket#1499

Previously, racket/base had three `define` implementations:

1. In `define-et-al.rkt`, an implementation with limited feature support.

2. In `define.rkt`, an heavyweight implementation supporting curried functions,
but still not optional parameters or defaults, which is used throughout much of
racket/base (and, until recently, was indirectly public via an export to
`#lang mzscheme`.)

3. In `kw.rkt`, the final "public" define, with full feature support.

This situation is unsatisfactory. After discussion (see
racket#5473), we're merging the first two `defines`
into a single implementation which supports everything except keywords and
optional arguments, is unsuitable for export, and lightweight enough to be
easily written using only kernel syntax.

This commit:
- implements the new define in define-et-al.rkt, provides it
- modifies files which used the old `-define` to use the new one via a `rename` require
  (found by searching the repo for `(?<![a-z0-9-])-define`)
- replaces the `define.rkt` implementations with a re-export of the new one

This is part of a larger effort to centralize and modernize some core syntax
constructs; see racket#5406 for more on that.

Replace the `define-values-for-syntax` implementation with one using only
kernel syntax, eliminating many requires from `racket/private/define.rkt`.

This is part of a larger effort to centralize and modernize some core syntax
constructs; see racket#5406 for more on that.

Previously, racket/base had three `define` implementations:

1. In `define-et-al.rkt`, an implementation with limited feature support.

2. In `define.rkt`, an heavyweight implementation supporting curried functions,
but still not optional parameters or defaults, which is used throughout much of
racket/base (and, until recently, was indirectly public via an export to
`#lang mzscheme`.)

3. In `kw.rkt`, the final "public" define, with full feature support.

This situation is unsatisfactory. After discussion (see
racket#5473), we're merging the first two `defines`
into a single implementation which supports everything except keywords and
optional arguments, is unsuitable for export, and lightweight enough to be
easily written using only kernel syntax.

This commit:
- implements the new define in define-et-al.rkt, provides it
- modifies files which used the old `-define` to use the new one via a `rename` require
  (found by searching the repo for `(?<![a-z0-9-])-define`)
- replaces the `define.rkt` implementations with a re-export of the new one

This is part of a larger effort to centralize and modernize some core syntax
constructs; see racket#5406 for more on that.

Replace the `define-values-for-syntax` implementation with one using only
kernel syntax, eliminating many requires from `racket/private/define.rkt`.

This is part of a larger effort to centralize and modernize some core syntax
constructs; see racket#5406 for more on that.

Previously, racket/base had three `define` implementations:

1. In `define-et-al.rkt`, an implementation with limited feature support.

2. In `define.rkt`, an heavyweight implementation supporting curried functions,
but still not optional parameters or defaults, which is used throughout much of
racket/base (and, until recently, was indirectly public via an export to
`#lang mzscheme`.)

3. In `kw.rkt`, the final "public" define, with full feature support.

This situation is unsatisfactory. After discussion (see
racket#5473), we're merging the first two `defines`
into a single implementation which supports everything except keywords and
optional arguments, is unsuitable for export, and lightweight enough to be
easily written using only kernel syntax.

This commit:
- implements the new define in define-et-al.rkt, provides it
- modifies files which used the old `-define` to use the new one via a `rename` require
  (found by searching the repo for `(?<![a-z0-9-])-define`)
- replaces the `define.rkt` implementations with a re-export of the new one

This is part of a larger effort to centralize and modernize some core syntax
constructs; see racket#5406 for more on that.

Replace the `define-values-for-syntax` implementation with one using only
kernel syntax, eliminating many requires from `racket/private/define.rkt`.

This is part of a larger effort to centralize and modernize some core syntax
constructs; see racket#5406 for more on that.

Previously, racket/base had three `define` implementations:

1. In `define-et-al.rkt`, an implementation with limited feature support.

2. In `define.rkt`, an heavyweight implementation supporting curried functions,
but still not optional parameters or defaults, which is used throughout much of
racket/base (and, until recently, was indirectly public via an export to
`#lang mzscheme`.)

3. In `kw.rkt`, the final "public" define, with full feature support.

This situation is unsatisfactory. After discussion (see
#5473), we're merging the first two `defines`
into a single implementation which supports everything except keywords and
optional arguments, is unsuitable for export, and lightweight enough to be
easily written using only kernel syntax.

This commit:
- implements the new define in define-et-al.rkt, provides it
- modifies files which used the old `-define` to use the new one via a `rename` require
  (found by searching the repo for `(?<![a-z0-9-])-define`)
- replaces the `define.rkt` implementations with a re-export of the new one

This is part of a larger effort to centralize and modernize some core syntax
constructs; see #5406 for more on that.

Replace the `define-values-for-syntax` implementation with one using only
kernel syntax, eliminating many requires from `racket/private/define.rkt`.

This is part of a larger effort to centralize and modernize some core syntax
constructs; see #5406 for more on that.

This rename makes twofold sense. First, `qq-and-or.rkt` is already more
than just what it says on the tin-- it also defines `let`, `let*`, and
`letrec`. Second, as part of the effort to reduce startup time, we plan
on merging more core macros into the same file; for more info about the
overall effort, see racket#5406

Testing: manually reviewed `git grep qq-and-or` in this repo; the only hits
are #%requires which this commit adjusts. Searched all `*.rkt` and `*.ss`
files in my copy of the package archive; the hits are `stxparse-info` which
appears to include a copy of a decent chunk of racket/base's implementation and
is broken anyway, and one hit in TR which will need a coordinated change.

Note that this requires a coordinated (backwards-compatible) change in Typed
Racket which should be merged at least a couple hours before this change is
merged. That's racket/typed-racket#1499

This rename makes twofold sense. First, `qq-and-or.rkt` is already more
than just what it says on the tin-- it also defines `let`, `let*`, and
`letrec`. Second, as part of the effort to reduce startup time, we plan
on merging more core macros into the same file; for more info about the
overall effort, see #5406

Testing: manually reviewed `git grep qq-and-or` in this repo; the only hits
are #%requires which this commit adjusts. Searched all `*.rkt` and `*.ss`
files in my copy of the package archive; the hits are `stxparse-info` which
appears to include a copy of a decent chunk of racket/base's implementation and
is broken anyway, and one hit in TR which will need a coordinated change.

Note that this requires a coordinated (backwards-compatible) change in Typed
Racket which should be merged at least a couple hours before this change is
merged. That's racket/typed-racket#1499

This is just `s/-define-syntax/define-syntax/` in a couple places
in letstx-scheme.rkt. The motivation is to remove the import of
`-define-syntax` which causes unpleasant behavior with `all-from`
(or `all-from-except`) provides.

This is part of a larger effort to centralize and modernize some
core syntax constructs; see #5406 for more on that.

Move cond.rkt's definitions (with no changes) into core-syntax.rkt, adding a
section header. Remove cond.rkt. Adjust the requires of other files
appropriately.

Note that this leads to some files requiring `core-syntax.rkt` more than
once; this is tidied in a future commit in this PR.

This is part of a larger effort to centralize and modernize some
core syntax constructs; see #5406 for more on that.

Move define-et-al.rkt's definitions (with no changes) into core-syntax.rkt,
adding a section header. Remove define-et-al.rkt. Adjust the requires of other
files appropriately.

Note that this leads to some files requiring `core-syntax.rkt` more than once;
this is tidied in a future commit in this PR.

This is part of a larger effort to centralize and modernize some core syntax
constructs; see #5406 for more on that.

Move define.rkt's definitions (with no changes) into core-syntax.rkt,
adding a section header. Remove define.rkt. Adjust the requires of other
files appropriately.

Note that this leads to some files requiring `core-syntax.rkt` more than
once; this is tidied in a future commit in this PR.

This is part of a larger effort to centralize and modernize some
core syntax constructs; see #5406 for more on that.

The previous three commits introduced duplicate requires of core-syntax.rkt.
This commit tidies them all up.

This is part of a larger effort to centralize and modernize some
core syntax constructs; see #5406 for more on that.