racket 标签 - Gitee.com

v6.1.1

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?)

8bb753b

2014-11-04 22:42

下载

v6.1

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.

8fc2f55

2014-08-03 01:29

下载

v6.0.1

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.

34c24ef

2014-05-09 04:08

下载

v6.0

Racket v6.0

Racket 6.0 has a new package system, including a catalog of
hundreds of already-available packages. Please visit

http://pkgs.racket-lang.org/

for an overview of the packages.

Racket versions 5.3.4 through 5.3.6 included "beta" versions of the
package system. Racket version 6.0 incorporates many improvements
suggested by preliminary experiences in those versions:

* A package is treated as a single collection by default, so it is
    even easier to use a GitHub repository as a package. Get started
    quickly:
      http://docs.racket-lang.org/pkg/getting-started.html

* DrRacket includes a new package manager GUI, available via the
    File|Package Manager ... menu item. The GUI is also available
    as a stand-alone program via the "gui-pkg-manager" package.

* The main Racket distribution has been separated into about 200
    packages. The Racket installer combines the core system with
    bundled versions of these packages.

Alternatively, you may now install a Minimal Racket distribution
    --- which is about 1/10 the size of the main distribution --- and
    add only those packages that you need.

* Package installation supports pre-built packages that include
    compiled byte code and rendered documentation, meaning packages can
    be installed quickly when built versions are available. All
    packages in the main distribution are available in pre-built form.

The recent 5.92 and 5.93 releases served as release candidates for 6.0,
and 6.0 includes a few additional repairs related to the package
system.

Further improvements to the package system are in the works, notably
including package documentation on the package-catalog web site.

COMPATIBILITY NOTE: PLaneT, the previous Racket package system, will
remain in place for the foreseeable future, but we expect all package
work to shift to the new system.

Beyond the package system, this release brings a number of other
changes:

* Racket's HTML documentation has a new and improved look, thanks to
    Matthew Butterick.

* The documentation includes a style guide, "How to Program Racket"
    http://docs.racket-lang.org/style/

* Racket's JIT compiler supports the ARM architecture.

* Racket supports the Mac's Retina display mode.

* The performance of the Typed Racket compiler improved by 50% on
    some typed programs; e.g., see http://bit.ly/1d0Ye4z

* The profiler provides a new mode that uses the errortrace library
    to produce fine-grained profiles.

* A new contract profiler reports how much time programs spend
    checking contracts, and which contracts are most expensive.

* The math/flonum library exports fast 105-bit precision operations.

* Check Syntax handles generated identifiers, especially those
    introduced by struct (e.g. field selectors) and Redex (e.g., e_1,
    e_2)

* 2htdp/batch-io includes functions for dealing with html/xml in
    files and web sites as X-expressions plus conveniences for
    web-based graph traversals.

* The `gen:set' generic interface extends set operations to work on
    user-defined types that implement set methods, as well as on other
    set-like built-in types, such as lists.

* Picts support conversion to SVG format.

* Under unix, Racket provides desktop entries (.desktop files) for
    its graphical executables.

b9bea2d

2014-02-27 06:07

下载

v5.93

b090e3f

2014-02-01 07:20

下载

v5.92

Racket v5.92

Racket 5.92 has a new package system, including a catalog of
hundreds of already-available packages. Please visit

http://pkgs.racket-lang.org/

for an overview of the packages.

Recent releases included the "beta" versions of the package system.
Racket version 5.92 incorporates many improvements suggested by these
preliminary experiences:

* A package is treated as a single collection by default, so it is
   even easier to use a Github repository as a package. Get started
   quickly:
     http://docs.racket-lang.org/pkg/getting-started.html

* DrRacket includes a new package manager GUI, available via the
   File|Package Manager ... menu item. The GUI is also available
   as a stand-alone program via the "gui-pkg-manager" package.

* The main Racket distribution has been separated into about 200
   packages. The Racket installer combines the core system with
   bundled versions of these packages.

Alternatively, you may now install a Minimal Racket distribution
   --- which is about 1/10 the size of the main distribution --- and
   add only those packages that you need.

* Package installation supports pre-built packages that include
   compiled byte code and rendered documentation, meaning packages can
   be installed quickly when built versions are available. All
   packages in the main distribution are available in pre-built form.

Further improvements are in the works, notably including package
documentation on the package-catalog web site.

COMPATIBILITY NOTE: PLaneT, the previous Racket package system, will
remain in place for the foreseeable future, but we expect all package
work to shift to the new system.

Beyond the package system, this release brings a number of other
changes:

* Racket's HTML documentation has a new and improved look, thanks to
   Matthew Butterick.

* The documentation includes a style guide, "How to Program Racket"
   http://docs.racket-lang.org/style/

* Racket's JIT compiler supports the ARM architecture.

* Racket supports the Mac's Retina display mode.

* The performance of the Typed Racket compiler improved by 50% on
   some typed programs; e.g., see http://bit.ly/1d0Ye4z

* The profiler provides a new mode that uses the errortrace library
   to produce fine-grained profiles.

* A new contract profiler reports how much time programs spend
   checking contracts, and which contracts are most expensive.

* The math/flonum library exports fast 105-bit precision operations.

* Check Syntax handles generated identifiers, especially those
   introduced by struct (e.g. field selectors) and Redex (e.g., e_1,
   e_2)

* 2htdp/batch-io includes functions for dealing with html/xml in
   files and web sites as X-expressions plus conveniences for
   web-based graph traversals.

* The `gen:set' generic interface extends set operations to work on
   user-defined types that implement set methods, as well as on other
   set-like built-in types, such as lists.

* Picts support conversion to SVG format.

* Under unix, Racket provides desktop entries (.desktop files) for
   its graphical executables.

8754879

2014-01-26 00:17

下载

v5.3.6

ded0c4a

2013-08-10 20:46

下载

v5.3.5

722dc82

2013-06-18 19:00

下载

v5.3.4

43d5976

2013-05-09 00:19

下载

v5.3.3

ca400d6

2013-02-16 04:36

下载

v5.3.2

Racket v5.3.2

Core Libraries:

* The new `math' library provides functions and data structures for
  working with numbers and collections of numbers.  Functions include
  non-elementary (such as gamma, zeta, Lambert's W), number-theoretic
  (factorization, modular arithmetic), linear algebra (arithmetic,
  decompositions), and statistical (expected values, order statistics,
  binning).  Data structures include arbitrary-precision bigfloats,
  probability distributions, and multidimensional arrays.

* The new `file/untar', `file/untgz', and `file/unzip' libraries support
  unpacking widely used archive formats.

* The new `lazy-require' form allows programs to delay the loading and
  instantiation of helper modules until they are needed.

* The new `data/bit-vector' library provides an implementation of bit
  vectors (a mutable sequence of booleans) supporting popcount.

* The `racket/generic' library allows the specification of default
  method implementations for core datatypes.

* The `openssl' library can verify hostnames and use the operating
  system's certificate store to verify certificates.

Package System:

* A new package system is in beta release.  This system will become
  Planet's successor.  It differs significantly from the latter.  For
  details, please read the documentation at
  http://docs.racket-lang.org/planet2/ and list your packages on the new
  index at https://pkg.racket-lang.org/.

* The `raco test' command supports testing by collection and package, in
  addition to by directory and file, with the "-c" and "-p" options.

Teaching Libraries:

* batch-io: the read and write functions work on Unix-style standard
  input and output.

DrRacket:

* DrRacket's GUI is more responsive.

* The automatic parenthesis insertion mode is improved.

Scribble:

* Scribble renders Markdown format files via the "--markdown"
  command-line flag.  Example use case: Generate documentation hosted on
  GitHub or BitBucket.

* Documentation cross-reference information is stored in an SQLite3
  database, which means that SQLite3 is required for building Racket
  documentation on Unix/Linux machines (but SQLite3 is included in
  Racket distributions for Windows and Mac OS X).

Using a database for cross-reference information significantly reduces
  the initial footprint of DrRacket, since DrRacket no longer needs to
  load all cross-reference information.

Typed Racket:

* Typed Racket programs can require `plot/typed' to draw plots.  List-
  and vector-accepting functions accept general sequences.

* Typed Racket supports Racket's delimited continuation and continuation
  mark operators.

Redex:

* Added more support for `define-judgment-form', including random
  generation for well-formed judgments and visualization of judgments.

Deprecation:

The following have been removed in this release:

* the `planet' command-line tool; use `raco planet' instead.

The following has been deprecated and will be removed in the August 2013
release:

* the `mzlib/class100' library; use `racket/class' instead.

df147de

2013-02-01 11:56

下载

v5.3.1

Racket v5.3.1

Racket:

* The `case' form dispatches on characters, fixnums, symbols, and
  keywords in logarithmic time.  (Thanks to Jon Zeppieri.)

* The new `racket/format' library provides new and improved
  string-formatting functions.

* Logging tools include improved filtering support based on the name
  of a logger.  A new `define-logger' form simplifies the use of
  named loggers.  Forms such as `log-debug' now support string
  formatting.

* The `for' forms now support `#:break' and `#:final' clauses.

* The new PLTCOMPILEDROOTS environment variable configures the
  search path for compiled bytecode.

DrRacket:

* Check Syntax now summarizes the documentation (i.e., the blue
  boxes) for the identifier at the insertion point in the top-right
  corner of the definitions window.

* Check Syntax now runs continuously for programs that declare their
  language within the source.  This mode has been available for
  several of the past releases, but now enabled by default.

* DrRacket can spell-check string constants (enable this in the Edit
  menu).

Typed Racket:

* Typed Racket interprets the Any type as a different contract.
  This may signal dynamic errors in some existing mixed
  typed/untyped programs.  The normal fix is to replace a use of Any
  with a more specific types.

* NaN is included in all of Typed Racket's floating-point types,
  which makes precise floating-point types easier to use.

* Typed Racket supports a `cast' operation with support for
  higher-order types.

* Typed Racket provides the `:query-type/args' and
  `:query-type/result' utilities to explore types at the REPL.

Miscellaneous:

* The `compatibility' collection provides features from Racket
  relatives, such as `defmacro' and mutable lists.  These features
  are provided to ease porting code to Racket.  Avoid them in modern
  Racket code.

* Screenshots of the widgets provided by the Racket GUI library are
  included in the documentation.  (Thanks to Diogo F. S. Ramos.)

* FrTime was ported to racket lang.  (Thanks to Patrick Mahoney.)

Deprecation:

The following has been deprecated and will be removed in the January
2013 release:

* the `planet' command-line tool; use `raco planet' instead.

The following has been deprecated and will be removed in the August
2013 release:

* the `mzlib/class100' library; use `racket/class' instead.

2f4c677

2012-11-08 03:50

下载

v5.3

Racket v5.3

* Submodules are nested module declarations that can be loaded and
  run independently from the enclosing module.  For an overview of
  submodules, see

http://blog.racket-lang.org/2012/06/submodules.html

* The futures visualizer is a graphical profiling tool for parallel
  programs using futures.  The tool shows a detailed execution
  timeline depicting the migration of futures between threads, and
  gives detailed information about each runtime synchronization that
  occurred during program execution.  In addition, `would-be-future'
  is a special type of future that always executes sequentially and
  records all potential barricades a regular future would encounter.

* Optimization Coach (formerly Performance Report) reports
  information about Racket's inlining optimizations.  Optimization
  Coach can be launched in any language through the View menu.

* The new `images/flomap' library defines floating-point bitmaps and
  fast image processing operations on them.  It is written in Typed
  Racket, so Typed Racket code may use it without the cost of
  contract checks.

* The new `json' library supports parsing and generating JSON.
  (Originally based on Dave Herman's planet library.)

* `racket/string' is extended with a set of simplified string
  manipulation functions that are more convenient than using
  regexps.  `regexp-match*' and friends can now be used with new
  keyword arguments to return specific matched regexp group/s and
  gaps between matches.

* The new `racket/generic' library allows generic function
  definitions, which dispatch to methods added to a structure type
  via the new `#:methods' keyword.

* The `class' form supports declaring a method abstract.  An
  abstract method prevents a class from being instantiated unless it
  is overridden.

* The contract library comes with support for interfaces, generics,
  prompts, continuation-marks, and structs.

* Most error messages use a new multi-line format that is more
  consistent with contract errors and accommodates more information.

* Typed Racket supports function definitions with keyword arguments;
  the startup time of Typed Racket programs has been sharply
  reduced.

* The new `ffi/com' library replaces MysterX; a compatibility
  `mysterx' library remains, but without ActiveX support.  The new
  `ffi/unsafe/com' library offers a more primitive and direct way to
  use COM classes and methods.

* There is now a very complete completion code for zsh.  It is not
  included in the distribution though; get it at http://goo.gl/DU8JK
  (This script and the bash completions will be included in the
  standard installers in future versions.)

--- DEPRECATION ----------------------------------------------------

Effective this release:

- The `tex2page' and `combinator-parser' libraries have been moved
    from the Racket distribution to PLaneT:

(require (planet plt/tex2page))
     (require (planet plt/combinator-parser))

The following has been deprecated and will be removed in the
January 2013 release:

- the `planet' command-line tool; use `raco planet' instead.

The following has been deprecated and will be removed in the
August 2013 release:

- the `mzlib/class100' library; use `racket/class' instead.

d8dc087

2012-08-07 12:10

下载

v5.2.1

Racket v5.2.1

* Performance improvements include the use of epoll()/kqueue() instead
  of select() for the Racket thread scheduler, cross-module inlining of
  small functions, and the use of SSE instead of x87 for JIT-compiled
  floating-point operations on platforms where SSE is always available
  (including x86_64 platforms).  A related change is the interning of
  literal numbers, strings, byte strings, characters, and regexps that
  appear in code and syntax objects.

* DrRacket uses a set of composable ray-traced icons available from the
  new `images' library collection.

* Typed Racket's `typecheck-fail' form allows macro creators to
  customize the error messages that Typed Racket produces.  This is
  especially useful when creating pattern matching macros.

* The performance of Redex's matcher has been substantially improved;
  depending on the model you should see improvements between 2x and 50x
  in the time it takes to reduce terms.

* Plots look nicer and are more correct at very small and very large
  scales.  New features include customizable dual axis ticks and
  transforms (e.g., log axes, date and currency ticks, axis interval
  collapse and stretch), stacked histograms, and 3D vector fields.  The
  legacy `fit' function and libfit have been removed.

* The `2htdp/universe' library's `big-bang' form supports an
  experimental game pad key handler.

* The `db' library now supports nested transactions and PostgreSQL
  arrays.  Bugs involving MySQL authentication and memory corruption in
  the SQLite bindings have been fixed.

* The Macro Stepper tool in DrRacket no longer executes a program after
  expanding it.

* In the DMdA teaching languages, infinite recursive signatures
  ("streams", for example) with no intervening `mixed' are now
  supported, and the signatures of record definitions without fields now
  have generators for use with `property'.

* MysterX's ActiveX support is deprecated and will be removed in the
  next release.  MysterX's core COM functionality will become deprecated
  in the next release, but COM functionality will be supported for the
  foreseeable future as a compatibility layer over a forthcoming
  `ffi/com' library.

0a3fcb2

2012-03-26 20:49

下载

v5.2

Racket v5.2

Release Highlights:

* DrRacket comes with an experimental, on-line check syntax tool,
  although this new tool is disabled default.  See below for more
  information.

* The new `db' library offers a high-level, functional interface to
  popular relational database systems, including PostgreSQL, MySQL,
  and SQLite, as well as other systems via ODBC.

* A new XREPL collection provides convenient commands for a plain
  racket REPL.  It is particularly convenient for people who prefer
  console-based work and alternative editors.  See also the new
  chapter on command-line tools and other editors at the end of the
  Racket Guide.

* The `plot' collection has been reimplemented in Racket.  It now
  offers PDF output, log axes, histograms, and more.  Some code that
  uses `plot' will still work, and some will need light porting.
  The `plot/compat' module offers expedient backward compatibility.

* DrRacket uses more conventional key bindings: `C-t' creates a new
  tab, `C-w' closes the current one, and `C-r' runs the definitions.
  On Mac OS X, the Command key is used.  See "Defining Custom
  Shortcuts" in the DrRacket manual for an example that uses the old
  key bindings.

* The new `raco link' command registers a directory as a collection,
  which allows the collection directory to reside outside the
  "collects" tree and without changing the PLTCOLLECTS environment
  variable.

* Typed Racket:
  - Typed Racket provides static performance debugging support to
    show which code gets optimized and point out code that does not.
    Use the "Performance Report" button in DrRacket.
  - More intuitive types in printouts in the REPL and in error
    messages.  Use `:query-result-type' to explore types, or
    `:print-type' for a full printout.
  - Typed Racket now supports defining function with optional
    arguments using the same syntax as Racket.

* Redex now supports specifying (and testing and automatically
  typesetting) judgment forms including type systems and SOS-style
  operational semantics.

* Fixed several GUI problems, including problems on Ubuntu 11.10
  (GTK+ 3) and 64-bit Mac OS X.

* Internal-definition expansion has changed to use `let*' semantics
  for sequences that contain no back references.  This change
  removes a performance penalty for using internal definitions
  instead of `let' in common cases, and it only changes the meaning
  of programs that capture continuations in internal definitions.
  Internal definitions are now considered preferable in style to
  `let'.

* Support for `begin-for-syntax' has been generalized; modules may
  now define and export both value bindings and syntax bindings
  (macros) at phase 1 and higher.

Due to a bug, phase 1 syntax (or higher) is not available in
  DrRacket's `#lang'-based REPL.  A simple workaround is to disable
  debugging in DrRacket (see "no debugging" radio button in detailed
  language dialog).

Additional Items:

* The `racket/gui' library (and Slideshow) provides more support for
  multiple-screen displays.

* DrRacket remembers whether an opened file used LF or CRLF line
  endings, and will continue using the same.  When creating a new
  file, a preference determines how it is saved.

* `net/url' can now follow HTTP redirections.

* The LNCS and JFP class files are no longer distributed with
  Racket.  Instead, they are downloaded on demand.

* The Algol language implementation is now available as a plain
  language using `#lang algol60'.

* The Racket-to-C compiler (as accessed via `raco ctool' or `mzc')
  has been removed; Racket's JIT has long provided better
  performance, and the FFI provides better access to C libraries.

* Contracts can be applied to exports with the new `contract-out'
  form within `provide', instead of a separate `provide/contract'
  form.  (The new `contract-out' form is implemented as a new kind
  of "provide pre-transformer".)

* The `date*' structure type is an extension of `date' with
  `nanosecond' and `time-zone-name' fields.

* New looping constructs: `for/sum' and `for/product'.

* Direct calls to keyword-accepting functions are now optimized to
  eliminate the overhead of keywords.  In addition, the compiler
  detects and logs warnings for keyword-argument mismatches.

* The libfit interface is available from `plot/deprecated/fit', and
  will be removed in the near future.

* The Unix installer has been re-done, and it is now more robust.

* The built-in reader and printer support for Honu is removed.
  (This functionality is re-implemented in Racket.)

On-line Check Syntax:

DrRacket now provides an on-line version of the syntax check tool,
which means that syntax checking runs automatically while you
continue to edit a program.  With this tool enabled, its annotations
(e.g., binding arrows) and actions (e.g., the renaming refactoring
and direct documentation links) are almost always available.

We have noticed that on-line syntax checking renders DrRacket
unstable on occasion, perhaps because it relies on relatively new
support for parallelism.  Occurrences of the problem are rare, but
they are not rare enough, which is why we have disabled the tool by
default.  At the same time, current users of the tool find it so
valuable that we felt it should be included in the release.  We
expect to track down the remaining problems and enable the tool by
default in near-future release.

To enable on-line syntax checking (for `#lang'-based programs only),
click on the red dot in the bottom right of DrRacket's window.  To
turn it off, click there again.

e42bfe3

2011-11-10 10:55

下载

v5.1.3

76809b9

2011-08-16 15:41

下载

v5.1.2

Racket v5.1.2

* The download page includes 64-bit installers for Mac OS X,
  Windows, and two Debian flavors.  Racket now supports OS X Lion.

* Racket now includes a new `racket/place' library to support
  parallelism, complementing `racket/future'.  Racket's parallel
  build process is now based on places instead of multiple OS
  processes.

Places support share-nothing parallelism and message-passing
  communication.  Compared to futures, places are heavyweight, but
  they have a simpler performance model.

* The syntax-certificate system has been replaced by a syntax-taint
  system.  Both certificates and taints were designed to protect
  otherwise inaccessible bindings from abuse when they appear in
  macro expansions.  Taints are simpler and lighter, and the switch
  closes known holes in the certificate system.  Macros that are not
  implemented with `syntax-rules' or `define-syntax-rule', however,
  must explicitly use `syntax-protect' to protect their expansions
  from abuse.

* The `net/url' library supports HTTPS connections, but beware that
  by default all sites are accepted (equivalent to ignoring a
  browser's warnings about untrusted certificates).

* Error messages in the student languages use a simplified
  vocabulary and consistent phrasings.  If you maintain curriculum
  material or teachpacks then please consider updating.  See the
  "Error Message Composition Guidelines" section in the
  documentation for details.

* Typed Racket: almost all core Racket data structures and
  operations are now accessible in Typed Racket (most of this work
  is due to prolific contributor Eric Dobson).  The performance of
  the typechecker has been significantly improved.

* The `scriblib/bibtex' library supports BibTeX-formatted citation
  databases in Scribble documents.  BibTeX can be tricky to parse,
  so please report failed entries as bug reports.

* The `for' forms now support an `#:unless' clause, and a
  nonnegative integer can be used as a sequence.  The new `compose1'
  function creates single-valued composition functions.  The
  `racket/function' library now provides `identity', `thunk', and
  `thunk*'.

* The license has been clarified: we now use LGPLv2.1 uniformly.
  (The license file used to specify LGPLv2, contrary to the download
  pages.)

9bd8e67

2011-08-04 03:23

下载

v5.1.1

Racket v5.1.1

* The new `racket/stream' library provides `stream-first',
  `stream-rest', a lazy `stream-cons', and so on.  Streams are a
  subtype of sequences, so they work in `for' forms.  Some sequence
  generators, such as `in-range', now produce streams.  A
  `racket/sequence' library replaces the old `racket/stream'
  library.

* The new `racket/syntax' library contains facilities useful for
  writing macros.  The new `syntax/srcloc' and `syntax/location'
  libraries provide support for manipulating source locations.

* The `racket/gui' library now supports multi-column list boxes and
  scrolling panels.

* The new `ffi/file' library is useful for writing foreign library
  bindings that cooperate with Racket's security guard mechanism.

* Generators from the `racket/generator' library can now have formal
  arguments that are used when the generator is fired up.

* Single-precision floating-point support is now enabled by default.
  Single-precision floats print differently from their default
  double-precision counterparts, new primitives convert between the
  two precisions, and new reader syntax supports single-precision
  literals.

* JIT improvements include a small change to aid x86 branch
  prediction on function-call returns, which can speed up some
  programs significantly.

* Typed Racket:
  - The numeric tower has been entirely overhauled.  TR programs can
    now use more precise types than before, and check more numeric
    properties, such as sign or range properties.
  - Fixnum optimizations have been improved and should apply more
    broadly.
  - The performance of the typechecker has been improved.  In
    particular, dispatch on large union types should typecheck much
    faster than before.

* The Stepper can now step through Lazy Racket programs.

* The `racket/future' library includes `fsemaphore' values, the
  `future' primitive no longer freezes futures (so a future can
  spawn new futures), and `future' log messages are more
  informative.

* PLaneT development links are now version-specific.

* The `2htdp/image' library now includes `overlay/align',
  `underlay/align', `overlay/align/offset' and
  `underlay/align/offset'.

* The network protocol for universes in `2htdp/universe' has
  changed, so that v5.1.1 is incompatible with earlier versions.

* The "DrScheme" application (which simply ran DrRacket in the last
  few releases) has been removed.  The "MrEd" GUI executables for
  Windows and Mac OS X have also been removed, although the "mred"
  console executable remains for Unix and Mac OS X to support old
  scripts.

6f8817d

2011-04-30 14:57

下载

v5.1

Racket v5.1

The most significant change in version 5.1 is a rewrite of the GUI
library:

http://blog.racket-lang.org/2010/12/racket-version-5.html

Unix/X users will see the biggest difference with this change,
because DrRacket and all Racket GUI programs now take on the desktop
theme for menus, buttons, and other GUI widgets.

In the long run, Racket GUI programs on all platforms will improve
as a result of the library rewrite.  In the short run, beware that
this first release of a new library will inevitably include a new
set of bugs.

Version 5.1 changes in more detail:

* The `racket/draw' library -- which implements the drawing half the
  GUI toolkit -- can be used independent of the `racket/gui/base'
  library and without a graphics display (e.g., without an X11
  connection).

The new library has one small incompatibility with the old GUI
  toolbox: 'xor drawing is no longer supported.  The new library has
  many additional features: rotation and general affine
  transformations, PDF and SVG drawing contexts, gradients, and
  alpha-channel bitmaps.

* The GRacket executable is no longer strictly necessary for running
  GUI programs, because the `racket/gui/base' library can be used
  from Racket.  To the degree that a platform distinguishes GUI and
  console applications, however, the GRacket executable still offers
  some additional GUI-specific functionality (e.g., single-instance
  support).

The new `racket/gui/base' library includes small incompatibilities
  with the old GUI toolbox: the `send-event',
  `current-ps-afm-file-paths', and `current-ps-cmap-file-paths'
  functions have been removed.  The `racket/gui/base' library
  re-exports `racket/draw', so it includes the same drawing
  functionality as before (except for 'xor drawing).

* The new `racket/snip' library can be used independently of
  `racket/gui/base' to work with graphical editor content (e.g.,
  images in student programs).  Like `racket/draw', the
  `racket/snip' library is re-exported by `racket/gui/base'.

* The Web Server includes a backwards incompatible change that
  prevents X-expressions and lists of bytes from being directly
  returned from servlets.  This change will increase performance for
  those types of responses and allow easier experimentation with
  response types.  Please see "collects/web-server/compat/0/README"
  in the installation to learn about porting your servlets forward.
  Don't worry.  It's easy.

* The new `raco demodularize' tool collapses a module's dependencies
  into a single module comprising the whole program.  This
  transformation currently provides no performance improvement, but
  is the basis for cross-module optimization and dead-code
  elimination tools to come.  The transformation is currently useful
  for static analysis of whole Racket programs.

* The picturing-programs teachpack, formerly installed via PLaneT,
  is now bundled with the standard distribution.  Use the teachpack
  with `(require picturing-programs)' instead of `(require
  installed-teachpacks/picturing-programs)'.  The old PLaneT-based
  installation procedure still works, but it now merely installs a
  stub that invokes the bundled version.

* Slideshow picts, `racket/draw' bitmaps, and images created with
  `2htdp/image' can now be used directly in Scribble documents.
  More generally, the new `file/convertible' protocol enables any
  value that is convertible to a PNG and/or PDF stream to be used as
  an image in a Scribble document.

* The Same game sports a new look and an improved scoring system.
  (The current known high score is 12,429; can you beat that?)

bee619f

2011-02-15 11:04

下载

v5.0.2

Racket v5.0.2

* Typed Racket's optimizer is now turned on by default; error
  messages have been simplified and clarified.

* Contracts: contracts on mutable containers allow functions or
  other higher order values, and contracts are checked when updating
  or dereferencing the containers.  The new contracts are slower
  than the old ones, so the old check-once functionality is still
  available.

A new dependent function contract combinator, `->i', properly
  assigns blame for contracts that violate themselves and the
  generated wrappers are more efficient than `->d'.  (Although it
  does more checking so your contracts may be faster or slower).

See the docs for `box/c', `hash/c', `vector/c', `vectorof' and
  `->i' for more details.

* The `when', `unless', `cond', `case', and `match' forms (in
  `racket/base' and derived languages) now allow immediate internal
  definitions.

* Web server: the formlets library provides more HTML form elements;
  `make-xexpr-response' supports a preamble for DTD declarations;
  `serve/servlet' supports stateless servlets.

* New WebSocket implementation, see `net/websocket' for details.

* The new `data' collection contains implementations of several data
  structures, including growable vectors and order-based
  dictionaries.

* `racket/match' is now significantly faster

* The Racket documentations are built in parallel by default.

* The stepper is now compatible with programs using the Universe
  teachpack.

* `2htdp/image': pinholes are now supported in the library (if you
  don't use pinhole primitives you will not see them); a number of
  new triangle functions added; supports conversion of images to
  color lists and back.  Also, cropping has been improved for
  scenes; see the documentation section on the nitty-gritty of
  pixels for details.

* Signatures have been moved to ASL, BSL, BSL+, ISL, and ISL+ (HtDP
  teaching languages) no longer support checked signatures.

* Student languages: one-armed `check-error' in all levels; ASL is
  extended with hash operations, and `define-datatype'.

* DMdA languages: Checking for parametric signatures is now eager.
  This catches errors earlier, but retains the asymptotic complexity
  properties; signatures for record types now have generators;
  `list-of' and `any' signatures are now provided.

371b00a

2010-11-07 12:46

下载

Gitee 极速下载/racket .gitee-modal { width: 500px !important; }

搜索帮助

Gitee 极速下载/racket