First and foremost, I have added some patches that disable MPROTECT for
some Racket executables and fix PR pkg/53467.
As for changes since the latest version, 6.11, these include:
* Changed the way some unsafe operations are exposed via `ffi/unsafe`
libraries to help smooth a future transition to a new runtime system.
* The `syntax-parse` form supports unwinding side-effects when it
backtracks, both explicitly with `~undo` patterns and implicitly
with the built-in managed state (using `syntax-parse-state-ref`,
etc).
* The `db` library supports SCRAM-SHA-256 authentication for backends
running PostgreSQL 10 or later. Client support for SCRAM and other
SASL mechanisms is provided by the new `sasl` library.
* The `lazy-require-syntax` form supports lazy loading of macro
transformers. Note that the macros must obey certain implementation
constraints (see the `lazy-require-syntax` documentation).
* Typed Racket no longer enforces types like `(U String (Boxof String))`
with the `any/c` contract. This fixes a type soundness issue, but may
affect performance. Please submit a bug report if you find a program
that runs significantly slower on v6.12 than earlier versions.
* Typed Racket's type instantiation (`inst`) uses `Any` for omitted type
arguments, allowing APIs to add additional type variables to functions
without breaking existing programs.
* `for/fold` users can customize the final result of a loop's computation
using the `#:result` keyword.
* The `--deps` option to `raco test` tests the packages the argument
packages depends on, in addition to testing the packages themselves.
For example, `raco test -p --deps pkg1 pkg2` tests all files from
`pkg1`, `pkg2`, and all of their dependencies.
* Typed Racket supports refinement types and dependent function types.
Previously an experimental feature, refinement types allow types to
describe more interesting properties of values, especially integers.
For example, this type shows that the `max` function always produces a
number at least as big as its inputs:
`(-> ([x : Integer] [y : Integer])
(Refine [z : Integer] (and (>= z x) (>= z y))))`
* DrRacket's Program Contour is significantly more efficient; using it
no longer hurts DrRacket's interactivity.
* The `web-server/formlets` library produces formlets that are
serializable, facilitating dynamic uses of formlets in stateless #lang
web-server servlets. The new `web-server/formlets/stateless` and
`web-server/formlets/unsafe` libraries provide additional support with
the same API.
* The `db` library supports the Cassandra database.
MASTER_SITES= site1 \
site2
style continuation lines to be simple repeated
MASTER_SITES+= site1
MASTER_SITES+= site2
lines. As previewed on tech-pkg. With thanks to rillig for fixing pkglint
accordingly.
Changes in Racket 6.6
- The new Macro Profiler command-line tool (`raco macro-profiler`) shows
how macros contribute to the final expanded code size of a program.
- Typed Racket supports intersection types. This allows the type system
to track more information, and for programmers to express more precise
types.
- Typed Racket produces up to 4x smaller compiled files compared with
Racket 6.5, reducing the size of the Racket distribution by 50M.
- Typed Racket issues warnings in cases where the contract generated for
`Any` was not strict enough in the past. These warnings will become
errors in a future release. Warnings are enabled via View -> Show Log
in DrRacket, and shown by default on command-line Racket.
- Typed Racket enforces uses of `cast` more correctly, by checking both
the "casted-to" and "casted-from" types. Previously, only the former
were checked. In some cases, this will produce contract errors in
programs that did not have errors before.
- `syntax-parse` raises an error when an ellipsis pattern has an empty
match rather than diverging, and it logs a warning when it statically
detects a nullable pattern, such as `((~seq) ...)`. In the next version
of Racket, it will reject the pattern instead, and it will remove
special handling that currently makes some uses of such patterns
terminate.
- `htdp/dir`: The `create-dir` function delivers data information for
files in a new field. The domain of its functions are backwards
compatible.
Changes in Racket 6.5
- Typed Racket and the racket/contract library generate code with lower
overhead, speeding up typed/untyped interaction in a number of gradual
typing programs we studied.
- Macros written using `syntax-parse` automatically emit more accurate
error messages.
- The contract profiler captures costs from more contract combinators,
including all those in the main distribution.
- Hash table and set iteration, via both existing and new non-generic
sequences, is more performant, up to twice as fast on microbenchmarks.
- The Racket optimizer detects many more optimization opportunities,
including when variables always hold numbers.
- The `db` library supports multi-result statements in MySQL.
- The `net/dns` library supports SRV records.
- The `racket/unix-socket` library supports listen and accept operations.
Changes in Racket 6.4:
- We fixed a security vulnerability in the web server. The existing
web server is vulnerable to a navigation attack if it is also
enabled to serve files statically; that is, any file readable by
the web server is accessible remotely. For more information see
http://blog.racket-lang.org/2016/02/racket-web-server-security-vulnerability.html
- DrRacket's scrolling is faster.
- Incremental garbage-collection mode can eliminate long pauses in a
program. For example, incremental mode is useful for avoiding pauses
in games and animations.
Programs must specifically request incremental mode with
`(collect-garbage 'incremental)`, but libraries such as
`2htdp/universe` include the request as part of the library's
implementation.
- The default package catalog is an HTTPS address instead of HTTP, and
package operations properly validate server certificates when using
HTTPS.
- Documentation may define their own categories for the manual top-
level page by using strings, rather than only symbols that name
pre-defined categories.
- The Racket cheat sheet is included in the main distribution.
- DrRacket is available in Bulgarian, thanks to Alexander Shopov.
- The contract Typed Racket generates for the `Any` type is more
permissive, allowing more typed/untyped programs to work without
contract errors.
- Redex supports binding specifications; describe which variables bind
in which expressions and your metafunctions and reduction relations
automatically become scope-sensitive. Thanks to Paul Stansifer for
this improvement.
- All `pict` functions accept `pict-convertible`s. This allows for
transparent interoperability between `pict` and libraries like
`2htdp/image`.
- The `raco profile` and `raco contract-profile` commands provide easy
access to profiling tools, without requiring program modifications.
Changes in Racket 6.3
- Racket's macro expander uses a new representation of binding called
"set of scopes". The new binding model provides a simpler
explanation of how macros preserve binding, especially across module
boundaries and in hygiene-bending expansions. The new expander is
mostly compatible with existing Racket macros, but there are some
incompatibilities. For the formally inclined, a research paper on
this macro system will appear at POPL next year:
http://www.cs.utah.edu/plt/scope-sets/
- Racket's GUI library now uses Gtk+ 3 when available, instead of Gtk+ 2.
Set the `PLT_GTK2` environment variable to select Gtk+ 2.
- Added a new Redex tutorial based on a week-long workshop in SLC.
- Better syntax error checking for Redex patterns that do not use
holes correctly.
- The blueboxes are more agressive about finding names to look up in
the docs, meaning they are useful much more often.
- Submodules are now fully supported in Typed Racket. Previously, some
uses of submodules would produce internal errors, making it hard to
`module+ test` and `module+ main` effectively in Typed Racket. The
switch to the set-of-scopes expander fixed these problems, and
submodules are now happily at home in Typed Racket.
- The `typed/racket/unsafe` library provides import and export forms
that circumvent contract generation. This improves performance for
typed-untyped interaction at the cost of safety and debuggability.
- Typed Racket provides experimental support for units (from
`racket/unit`).
- The experimental `define-new-subtype` form allows overlaying finer
distinctions between otherwise identical types, similar to Haskell's
`newtype`.
- The `Promise` type constructor changes in a backwards-incompatible
way to exclude promises created with `promise/name`.
- The `unstable-*` packages are out of the main distribution. Most of
their contents have been either merged with established Racket
libraries or spun off as their own packages. This change is
backwards compatible for packages that properly list their
dependencies. Full details:
http://blog.racket-lang.org/2015/10/retiring-unstable.html
- edu: `big-bang` supports a display-mode clause so that world
programs can take over the entire screen.
Changes in Racket 6.2.1
- For the How to Design Programs teaching languages, DrRacket offers
an option to use the old style for printing the constants `true`,
`false`, and `empty` instead of `#true`, `#false`, and `'()`.
- The teaching languages come with some additional functions to match
the August 2015 stable release of HtDP 2nd edition.
- A repair to the compiler avoids an infinite loop at compile time for
certain expressions that should loop forever at run time.
