Up to [cvs.NetBSD.org] / pkgsrc / lang / racket
Request diff between arbitrary revisions
Keyword substitution: kv
Default branch: MAIN
racket: update to 9.3 - The raco setup command can generate markdown documentation, using the --doc-markdown option. - The "#lang" teaching languages (BSL, …, ISL+; plus DeinProgram) have reached parity with the ones chosen using the Language dialog, and are the recommended choice. - DrRacket’s background expansion disables errortrace annotations, for faster syntax checking. - The raco pkg install command includes new options that provide more install-time configuration flexibility: --adjacent-deps, --destdir, and --attach, and a refined --skip-installed. - The ffi/unsafe/runtime-lib library provides a define-runtime-lib mechanism similar to define-runtime-path, allowing location of libraries located relative to a source file. - The prompt-tag/c contract generator no longer performs checking on call/cc when the #:call/cc option is not present. - The impersonate-prompt-tag function takes an additional argument that allows checking and update of results for composable continuations. - The error-syntax->srcloc-handler parameter provides control over the mapping from syntactic forms to source locations for error handling. - Uses of (tcp-listen 0) will retry when it fails with “address in use”. - The racket/base module requires fewer internal modules and instantiations. - The file/zip package provides a new mechanism for greatly increased control over zip file generation, allowing in-memory file sources and per-file compression control.
racket: update to 9.2 - The match form checks that when non-linear patterns (patterns where the same variable is used multiple times) are used with ..., the two parts of the matched value actually are equal. Additionally, match rejects non-linear patterns where one use of the variable is used with ... and another is not. This repair could cause existing code to fail. - Typed Racket types for the asin and acos procedures correctly handle situations where the function produces a complex number, avoiding unsound results that were previously possible. This repair could cause existing code to fail at compile time. - The #%foreign-inline core syntactic form provides unsafe access to facilities provided at the linklet layer by a Racket implementation. This means that any code that handles all core forms by enumeration will need to be updated. - Unicode 17.0 is used for character and string operations. - This release includes internal support for a more static foreign interface (to be used in a future package). - The terminal-file-position function counts bytes written to ports connected to a terminal, such as stdin and stderr. - Cross-phase persistent modules allow more types of quoted data. - The implementations of member, memw, when, unless, let/ec, and cond are rewritten to use only racket/kernel syntax - The impersonator-property-predicate-procedure? function identifies procedures created by make-impersonator-property. - In Typed Racket, polymorphic struct types are printed using type arguments (e.g., (Array Byte)) rather than exposing an internal representation. - The stepper-display of numbers better matches the language settings. - Scribble documents that do not use the Racket-manual style get an initial-scale of 1.0, instead of the manual style-0.8, but this can be configured using the initial-scale property. - By default, margin notes appear inline for narrow displays in all styles, not just in the Racket-manual style. - Big-bang programs distributed as .dmg files correctly handle the close-on-stop feature. - There are many other repairs and documentation improvements!
racket: update to 9.1 - Documentation organization and navigation can be specialized by language family, to allow users to interact with documentation in a way that is tailored to that language family. This is currently used by Rhombus. - The `for` form and its variants accept an `#:on-length-mismatch` specifier. 3.18 Iterations and Comprehensions: for, for/list, ... - DrRacket improves the GUI for choosing color schemes. - DrRacket has curved syntax arrows. The degree of curvature indicates the relative left- or right-displacement of the arrow's target. - DrRacket's "Insert Large Letters" uses characters that match the comment syntax of the buffer's language, making it useful (and fun!) in Rhombus. - The `exn-classify-errno` maps network and filesystem error numbers on various platforms to posix-standard symbols, to enable more portable code. 10.2 Exceptions - The behavior of Racket BC on certain character operations (most notably `eq?`) is changed to match that of Racket CS, with a small performance penalty for these operations for BC programs. 19 Performance 1.5 Implementations - The `make-struct-type` procedure can inherit the current inspector using a `'current` flag. This is the default behavior, but there are situations in which it's not possible to refer to the current inspector. 5.2 Creating Structure Types - Bundle configurations can better control the conventions for locating shared object files with the `--enable-sofind=3D<conv>` flags. - The `system-type` function can report on platform and shared-object-library conventions with new flags. 15.8 Environment and Runtime Information - The `openssl/legacy` library makes it possible to access OpenSSL's built-in "legacy" provider, to get access to insecure and outdated algorithms. OpenSSL: Secure Communication - Typed Racket improves expected type propagation for keyword argument functions. - There are many other repairs and documentation improvements!
racket: update to 9.0
- Supports parallel threads
- Parallel threads can be created using the #:pool argument to
thread creation.
- Threads created with #:keep set to 'results
will record their results for later retrieval with thread-wait.
- The black-box wrapper prevents the optimizing compiler from
optimizing away certain computations entirely. This can be helpful
in ensuring that benchmarks are accurate.
- The decompile-linklet function can map linklets back to
s-expressions.
- When using BC Racket, the processor-count function is changed to
always return the parallel count.
- We now distribute “natipkg” packages for AArch64, useful for
package-build and package-testing infrastructure.
- Check Syntax tracks identifiers more deeply nested in the “origin”
field of syntax objects.
- The math library includes Weibull distributions.
- There are many other repairs and documentation improvements
racket: install shell completion files in default pkgsrc paths Bump PKGREVISION.
lang/racket, lang/racket-minimal: Update to 8.15
While here:
1. Patch around https://github.com/racket/racket/issues/5122 (seek in
boot file petite failed) and
https://github.com/racket/racket/issues/5049 (8.13 fails to build
on NetBSD) by using argv[0] instead of
realpath("/proc/curproc/file") as the reference point for
executable-relative paths.
1. Work around https://github.com/racket/racket/issues/4290
(Regression since Racket 8.5: fonts are required to build
successfully) by pulling in a small font at build-time.
3. Add PRINT_PLIST_AWK to assist with future updates.
lang/racket: Use ${PREFIX}, not my dev tree in my home directory!
Not sure how I managed to break this for lang/racket, but not for
lang/racket-textual.
lang/racket{,-textual}: update to 8.11.1
8.11.1:
This bug-fix release repairs a problem with building from source when using the “builtpkgs” source distribution.
8.11:
Match clauses can include a #:do option to allow evaluation of code and bindings before a following #:when clause. See match.
JSON Serialization supports indentation with an #:indent option to write-json. See write-json.
An initiate-sequence function simplifies the creation of sequences. See initiate-sequence.
The :do-in form allows an inner definition sequence. See :do-in.
The redex-define form allows pattern-matching in PLT Redex using a define-like syntax. See redex-define.
Racket and Chez Scheme use Robert L. Smith’s “Algorithm 116” for division of complex numbers. See Robert L. Smith. 1962. Algorithm 116: Complex division. Commun. ACM 5, 8 (Aug. 1962), 435. https://dl.acm.org/doi/10.1145/368637.368661.
DrRacket has indentation guides that provide visual cues indicating how code is indented and grouped, accessible by using (<menu-key>-shift-i). See text:indent-guides<%>.
“Comment-out” menu items can be specific to the #lang used by the current file. See Comments.
Unused identifiers have a tooltip indicating that they have no bound occurrences.
Quickscript includes a new form of scripting in the form of “hook” functions that can be attached to existing events. See Hooks.
Plots include plot-inset and plot-legend-padding parameters to control the amount of space left unused around the plot edge and plot legend. See plot-inset.
There are many other documentation improvements, optimizations, and bug fixes!
racket: Update to 8.10
pkgsrc notes:
- Reset maintainer since ASau retired years ago.
- Move etc/racket/config.rktd from PLIST to CONF_FILES.
- Patch away some upstream mistakes:
. don't hard-code linking against /usr/pkg/lib/libncurses.a
https://github.com/racket/racket/issues/4734
. don't hard-code linking against /usr/lib/i18n/libiconv_std.a
https://github.com/racket/racket/issues/4736
- Remove most paxctl patches -- upstream does it now (only patches
remaining obviate need for /usr/sbin to be in PATH by passing the
full path through PAXCTl environment variable).
- Make paxctl business NetBSD-only.
Too many upstream changes to list since 6.12:
https://download.racket-lang.org/v8.10.html
https://download.racket-lang.org/v8.9.html
https://download.racket-lang.org/v8.8.html
https://download.racket-lang.org/v8.7.html
https://download.racket-lang.org/v8.6.html
https://download.racket-lang.org/v8.5.html
https://download.racket-lang.org/v8.4.html
https://download.racket-lang.org/v8.3.html
https://download.racket-lang.org/v8.1.html
https://download.racket-lang.org/v8.1.html
https://download.racket-lang.org/v8.0.html
https://download.racket-lang.org/v7.9.html
https://download.racket-lang.org/v7.8.html
https://download.racket-lang.org/v7.7.html
https://download.racket-lang.org/v7.6.html
https://download.racket-lang.org/v7.5.html
https://download.racket-lang.org/v7.4.html
https://download.racket-lang.org/v7.3.html
https://download.racket-lang.org/v7.2.html
https://download.racket-lang.org/v7.1.html
https://download.racket-lang.org/v7.0.html
Updated lang/racket to version 6.12. 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.
Update to v6.11
* 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.
Update to Racket 6.7. Changes are not known.
Update to Racket 6.6 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.
Update to Racket 6.4 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.
Update to Racket 6.3
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.
Update to Racket 6.1.1 Changes: * 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 Dvorak. * 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?)
Update of racket ports to version 6.1.1. Coordinated with asau. Changes, as per upstream changelog: - Bug repairs and other changes noted in the documentation - Changed use-before-definition to be an error instead of producing an #<undefined> value - Removed the mzlib/class100 library Also changed the racket port to use mk/jpeg.buildlink3.mk.
Update to Racket 6.0.1
Changes in version 6.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.
Changes in version 6.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.
* 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.
add missing file
Update to Racket 5.3.6 Racket 5.3.6 This is a bug-fix release. It eliminates errors from v5.3.5 that people have found over the summer. Racket 5.3.5 This is a special-purpose release to match the arrival of "Realm of Racket" in bookstores. Racket v.5.3.5 adds a single `realm' collection to the v5.3.4 release. The new collection contains the source code that readers of Realm may wish to use for experiments. Racket 5.3.4 * Extflonums (80-bit floating-point numbers) are supported on some x86/x86_64 platforms -- including Windows, and including platforms where Racket is compiled to use SSE instructions for flonum arithmetic. Thanks to Michael Filonenko. * OS X: DrRacket and all of the other apps are now signed with an official key. * Tally Maze: a new game based an enumeration of 2d mazes. * The Optimization Coach, a DrRacket plugin, has been moved from the Racket distribution to the Racket package repository. Install it with: raco pkg install optimization-coach * Redex: `define-union-language' now merges productions when languages define the same nonterminals. Thanks to William Bowman. * The `srfi/19' library is now compatible with the date structure type exported by `racket/base'.
Update to Racket 5.3.2 Changes in 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. Changes in 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.
Update to Racket 5.3
Changes in Racket 5.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.
Update to Racket 5.2.1
Changes in Racket 5.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.
Update to Racket 5.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.
Update Racket to version 5.1.3 Changes in Racket 5.1.3 This is a bugfix release, resolving the DrRacket issue with the contour view. In addition, two tex files with problematic licensing were removed. Changes in Racket 5.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.)
Update to Racket 5.1.1
Changes in version 5.1.1, May 2011:
Enabled single-precision floats by default
Added single-flonum?
Changed eqv? so that inexacts are equivalent only when they
have the same precision
Changed file-or-directory-permission to add 'bits mode
and permission-setting mode
Added special treatment of void as an 'inferred-name property
Removed the "MrEd" compatability executable under Windows
and Mac OS X, but the "mred" compatibility script remains
racket/gui: added multi-column support to list-box%
racket/gui: added scrollbar support to panel%, vertical-panel%,
and horizontal-panel%
racket/gui: added 'wheel-left and 'wheel-right events
racket/file: add user-read-bit, etc.
racket/contract: removed some (undocumented) exports.
Changes in version 5.1, February 2011
Renamed "proxy" to "impersonator"
Added current-get-interaction-input-port, which enables
racket/gui events to be dispatched while a REPL is blocked
Changed equal? to equate C pointers when they refer to the
same address
Internal: weak boxes are cleared before non-will-like
finalizers; use late-weak boxes to get the old behavior
Changes in version 5.0.2, October 2010
Changed body of `when', `unless', `cond' clauses, `case'
clauses, and `match' clauses to be internal-definition contexts
Swapped unsafe-vector*-ref with unsafe-vector-ref, etc.
Added ->i to the contract library, improved ->*, adding #:pre and
#:post, as well as making the optional arguments clause optional.
Added #true and #false, and changed #t/#T and #f/#F to
require a delimiter afterward
Added print-boolean-long-form
Added read-accept-lang, which is set to #t when
reading a module
Added flonum?
Changed continuation-marks to accept a #f argument
to produce an empty set of marks
Added fxvectors
Added unsafe-{s,u}16-{ref,set!}
Added prop:proxy-of
Added proxies to go with chaperones, and renamed chaperone property
as proxy property; beware that the word "proxy" will change in
a future version, perhaps to "impersonator"
Added collection-file-path and collection splicing at the file
level
Update to Racket 5.0.1 Continuation barriers now block only downward continuation jumps and allow escapes through full continuations Changed internal-definition handling to allow expressions mixed with definitions Added support for subprocesses as new process groups Added support for best-effort termination of subprocess by a custodian Added flreal-part, flimag-part, make-flrectangular, and unsafe variants Added fl->eact-integer, fl->fx, and unsafe-fl->fx Added #:async-apply option to _fun Added chaperone-evt Added identifier-prune-to-source-module Changed apply binding to enable lower-level optimizations Upgraded to libffi 3.0.9+
Import Racket 5.0 as lang/racket. Import textual Racket version as lang/racket-textual. Racket (formerly PLT Scheme) is a specific dialect of the Lisp language based on the Scheme branch of the Lisp family.
Initial revision