Racket 6.2.1

Version 6.2.1 patches the recent v6.2 release in three small ways:

* 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.

Merge git.racket-lang.org:plt

Racket v6.2

With this release we are taking a major step forward to get our user
community even more involved than in the past. Over the past six months,
we have re-organized the Racket code base into a small core code repo
and many other package repos, all found on github. If you have time and
if you wish to get involved, please take a look at the github repos and
find your favorite places to learn, fix, and enhance our world.

The core repo is at https://github.com/plt/racket, and the
package repos are listed at https://github.com/racket/.

core repo

* The package manager supports a direct references to Git repositories
  via "git:https://[...]", "http:https://[...].git", and "https://[...].git" URLs.
  (Previously, only references to GitHub were supported.)

* A `--clone` option for `raco pkg install` or `raco pkg update`
  facilitates Git-based package development. If a package X has a Git
  repository source, installing and updating the package pulls from the
  repository in a read-only mode. Using `raco pkg update --clone X`
  switches the local installation to a repository checkout that is
  suitable for modifying the package implementation, issuing pull
  requests, pushing changes, and so on.

  Using `raco pkg update --lookup X` switches the package back to the
  default installation mode.

drracket

* Its on-line check syntax works with graphical content.

* Increased availability of DrRacket's blueboxes, including method and
  constructor information.

* The "Open Require Path" menu item supports ".." in relative pathnames.

data

* Added data/enumerate, a library that supports efficient enumeration of
  data structures

redex

* Its redex-check facility uses data (in addition to random) enumeration
  to try to find counter-examples.

* Its generate-term function accepts additional arguments to return the
  "i"-th member of a pattern using data/enumerate (meaning it
  efficiently supports very large values of "i").

* The examples collection includes Launchbury's 1993 big-step lazy semantics.

htdp

* 2htdp/image's polygon may be built out of bezier curves instead of
  just straight lines (see the docs for "pulled-point").

* 2htdp/abstraction is a teachpack for instructors and students who wish
  to use for/* loops, match, define-type and type-cases in ISL and ISL+.

* 2htdp/universe programs can be exported using DrRacket's executable
  creation mechanism and they behave properly when run independently.

typed-racket

* Typed Racket in DrRacket displays tooltips that show the types of
  expressions. Tooltips are also displayed for type errors.

* Typed Racket loads generated contracts only when needed. This reduces
  memory use and startup time for Typed Racket programs.

* Typed Racket has improved support for prefab structures, future
  semaphores, and async channels.

* Typed Racket understands when two different variables refer to the
  same thing, and updates types accordingly. This particularly improves
  the type checking of macros such as `match`.

Racket v6.1.1

* The MAC OS X YOSEMITE compatibility problems are fixed. We
  bundled a patched Pango text-drawing library with Racket.

* The WINDOWS [32-bit] releases fixes the window-update crashes.
  We bundled a patched Cairo drawing library with Racket.

* TYPED RACKET closes two safety holes in the exception system.
  The revised type system restricts `raise' to send only
  instances of the `exn' structure type and flat data to
  handlers. It also checks exception handlers properly.
  NOTE: Previously well-typed programs may fail to typecheck.

* TYPED RACKET'S typed regions support casts and predicates.

* 2HTDP/IMAGE'S notion of equality ignores an image's baseline.

* The PACKAGE MANAGER supports a binary library installation mode,
  which allows users to install packages without source or documentation.
  Use the `--binary-lib' option with `raco pkg install'.

* The new DRRACKET-TOOL-LIB package factors out parts of DrRacket's
  IDE so that they can be reused with other editors, such as Emacs.

* The COMPILER'S use-before-defined analysis has been repaired for
  certain forms of nested `letrec', some `let' forms, and some
  uses of `set!' or `with-continuation-mark'.

* The COMPILER performs additional bytecode optimizations.
  Thanks to Gustavo Massaccesi.

* The CML library comes with a new `replace-evt' event constructor.
  Thanks to Jan Dvořák.

* REDEX'S benchmark suite comes with a description of the benchmark
  programs.

* REDEX'S metafunctions can be typeset using the "large left brace"
  notation for conditionals.

* The CONTRACT library comes with an improved `contract-stronger?'.
  Its error messages note that the contract itself might be wrong.

* The GUI library is DPI-aware on Windows.

* The OPENSSL library supports Server Name Indication for servers.
  Thanks to Jay Kominek.

* The SYNTAX/PARSE library allows the definition of new pattern
  forms via pattern expanders, similar to match expanders.
  Thanks to Alex Knauth.

* OpenGL on Linux no longer depends on libgtkgl, and core profiles
  are supported (see `set-legacy?').

* The TEACHING LANGUAGES' unit test framework supports
  `check-satisfied', a construct for checking whether a result
  satisfies a predicate, e.g.: (check-satisfied (sort l) sorted?)

Racket v6.1

The MAJOR INNOVATION concerns local recursive variable definitions.
Instead of initializing variables with an `undefined' value, Racket
raises an exception when such a variable is used before its definition.
(Thanks to Claire Alvis for adapting Dybvig's "Fixing Letrec" work.)

Since programs are rarely intended to produce #<undefined>, raising an
exception provides early and improved feedback. Module-level variables
have always triggered such an exception when used too early, and this
change finally gives local bindings --- including class fields --- the
same meaning.

This change is backwards-incompatible with prior releases of Racket.
Aside from exposing a few bugs, the change will mainly affect programs
that include

(define undefined (letrec ([x x]) x))

to obtain the #<undefined> value. In its stead, Racket provides the same
value via the `racket/undefined' library (which was introduced in the
previous release). Programmers are encouraged to use it in place of the
pattern above to obtain the "undefined" value.

The release also includes the following SMALL CHANGES:

* PLUMBERS generalize the flush-on-exit capability of primitive output
  ports to enable arbitrary flushing actions and to give programmers
  control over the timing of flushes (i.e., a composable `atexit').  New
  functions include `current-plumber', `plumber-add-flush!', and
  `plumber-flush-all'.

* CONTRACTS: the contract system's random testing facility has been
  strengthened so that it can easily find simple mistakes in contracted
  data structure implementations (e.g. an accidental reverse of a
  conditional in a heap invariant check).

* REDEX: the semantics of mis-match patterns (variables followed by _!_)
  inside ellipses has changed in a backwards-incompatible way. This
  change simplifies the patterns' semantics and increases the usefulness
  of these patterns.

* TEACHING LANGUAGES: `check-random' is an addition to the preferred
  unit testing framework in the teaching languages. It enables the
  testing of students' functions that use random-number
  generation. (Thanks to David Van Horn (UMaryland) for proposing this
  idea.)

* Upgraded and normalized versions of GRAPHICS LIBRARIES and
  dependencies (Pango, Cairo, GLib, etc.) that are bundled with Racket
  on Windows and Mac OS X. For example, FreeType support is consistently
  enabled.

* TYPED RACKET: its standard library includes contracted exports from
  the Racket standard library, such as the formatting combinators of
  `racket/format'. It also supports Racket's asynchronous channels; see
  the `typed/racket/async-channel' library.

* SSL: The openssl library supports forward secrecy via DHE and ECDHE
  cipher suites (thanks to Edward Lee) and Server Name Indication
  (thanks to Jay Kominek).

* The `mzlib/class100' library has been REMOVED. Use `racket/class'
  instead.

Racket v6.0.1

* A new `racket/undefined` library exports `undefined` as the value
  currently produced by

    (letrec ([x x]) x)

  This library anticipates a future where that expression will raise
  an exception. The `racket/undefined` library will continue to offer
  the `undefined` value as a bridge between versions and as a last
  resort.

* The drawing and GUI libraries provide improved support for
  high-resolution bitmaps and their use on Retina displays. For
  example, `read-bitmap` includes a `#:try-@2x?` option to trigger
  substitutions through the usual "@2x" naming convention.

* Check Syntax cooperates with Typed Racket to show arrows and other
  Check Syntax highlighting even when there is a type error.

* Functions provided via contract-out that have first-order contracts
  perform better.

* The contract boundary between typed/untyped modules is much less
  expensive. Typed Racket now avoids generating contracts for places
  where contracts failures cannot happen.

* Occurrence typing now works better with when/unless. Example:

    (let ((x (read)))
      (unless (number? x) (error 'bad-input))
      (add1 x))

* Types in Typed Racket are now pretty-printed.

* Function types can now be written in prefix style, which is now
  preferred and is used for printing. Infix function types are still
  accepted for backwards compatibility.

* A new `->*' type constructor is used for writing types for functions
  with optional and keyword arguments. The notation is similar to the
  matching contract combinator.

* Typed Racket forms do not have a `:' suffix by default now. For
  example, the `struct' form replaces `struct:'. The suffixed versions
  are all provided for backwards compatibility.

* Typed Racket now has preliminary support for classes and
  objects. However, it is still experimental and the APIs are subject
  to change.

* Type aliases in Typed Racket now support recursion and mutual
  recursion. For example, `(define-type (MyList X) (U Null (Pair X
  (MyList X))))' is now a valid type alias.

* Plot correctly renders intersecting 3D graphs and non-grid-aligned
  3D rectangles.

* Elements in plots output in PDF/PS format have the same relative
  scale as in other formats. In particular, it is not necessary to
  adjust `plot-font-size` to make PDF plots look the same as PNG.