kpriv/pkgsrc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pkgsrc/lang/racket-textual/PLIST

1651 lines
88 KiB
Text
Raw Normal View History

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?)
2015-08-05 23:14:29 +02:00
@comment $NetBSD: PLIST,v 1.12 2015/08/05 21:14:29 asau Exp $
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.
2010-07-20 04:15:50 +02:00
bin/racket
bin/raco
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.
2014-06-15 11:35:28 +02:00
etc/racket/config.rktd
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.
2010-07-20 04:15:50 +02:00
include/racket/escheme.h
include/racket/ext.exp
include/racket/mzconfig.h
include/racket/mzscheme.exp
include/racket/mzscheme3m.exp
include/racket/scheme.h
include/racket/schemef.h
include/racket/schemegc2.h
include/racket/schemex.h
include/racket/schemexm.h
include/racket/schexn.h
include/racket/schgc2obj.h
include/racket/schthread.h
include/racket/schvers.h
include/racket/sconfig.h
include/racket/stypes.h
include/racket/uconfig.h
lib/racket/buildinfo
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.
2014-06-15 11:35:28 +02:00
lib/racket/gracket
lib/racket/launchers.rktd
lib/racket/mans.rktd
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.
2010-07-20 04:15:50 +02:00
lib/racket/mzdyn3m.o
lib/racket/starter
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.
2014-06-15 11:35:28 +02:00
lib/racket/starter-sh
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.
2010-07-20 04:15:50 +02:00
man/man1/racket.1
man/man1/raco.1
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.
2014-06-15 11:35:28 +02:00
share/racket/COPYING-libscheme.txt
share/racket/COPYING.txt
share/racket/COPYING_LESSER.txt
share/racket/collects/acks/acks.rkt
share/racket/collects/acks/compiled/acks_rkt.dep
share/racket/collects/acks/compiled/acks_rkt.zo
share/racket/collects/compiler/cm-accomplice.rkt
share/racket/collects/compiler/cm.rkt
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/compiler/compilation-path.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/compiler/compile-file.rkt
share/racket/collects/compiler/compiled/cm-accomplice_rkt.dep
share/racket/collects/compiler/compiled/cm-accomplice_rkt.zo
share/racket/collects/compiler/compiled/cm_rkt.dep
share/racket/collects/compiler/compiled/cm_rkt.zo
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/compiler/compiled/compilation-path_rkt.dep
share/racket/collects/compiler/compiled/compilation-path_rkt.zo
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/compiler/compiled/compile-file_rkt.dep
share/racket/collects/compiler/compiled/compile-file_rkt.zo
share/racket/collects/compiler/compiled/compiler_rkt.dep
share/racket/collects/compiler/compiled/compiler_rkt.zo
share/racket/collects/compiler/compiled/distribute_rkt.dep
share/racket/collects/compiler/compiled/distribute_rkt.zo
share/racket/collects/compiler/compiled/embed_rkt.dep
share/racket/collects/compiler/compiled/embed_rkt.zo
share/racket/collects/compiler/compiled/find-exe_rkt.dep
share/racket/collects/compiler/compiled/find-exe_rkt.zo
share/racket/collects/compiler/compiled/option_rkt.dep
share/racket/collects/compiler/compiled/option_rkt.zo
share/racket/collects/compiler/compiler.rkt
share/racket/collects/compiler/distribute.rkt
share/racket/collects/compiler/embed.rkt
share/racket/collects/compiler/find-exe.rkt
share/racket/collects/compiler/option.rkt
share/racket/collects/compiler/private/collects-path.rkt
share/racket/collects/compiler/private/compiled/collects-path_rkt.dep
share/racket/collects/compiler/private/compiled/collects-path_rkt.zo
share/racket/collects/compiler/private/compiled/configdir_rkt.dep
share/racket/collects/compiler/private/compiled/configdir_rkt.zo
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?)
2015-08-05 23:14:29 +02:00
share/racket/collects/compiler/private/compiled/dep_rkt.dep
share/racket/collects/compiler/private/compiled/dep_rkt.zo
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/compiler/private/compiled/elf_rkt.dep
share/racket/collects/compiler/private/compiled/elf_rkt.zo
share/racket/collects/compiler/private/compiled/embed_rkt.dep
share/racket/collects/compiler/private/compiled/embed_rkt.zo
share/racket/collects/compiler/private/compiled/macfw_rkt.dep
share/racket/collects/compiler/private/compiled/macfw_rkt.zo
share/racket/collects/compiler/private/compiled/mach-o_rkt.dep
share/racket/collects/compiler/private/compiled/mach-o_rkt.zo
share/racket/collects/compiler/private/compiled/windlldir_rkt.dep
share/racket/collects/compiler/private/compiled/windlldir_rkt.zo
share/racket/collects/compiler/private/compiled/winsubsys_rkt.dep
share/racket/collects/compiler/private/compiled/winsubsys_rkt.zo
share/racket/collects/compiler/private/compiled/winutf16_rkt.dep
share/racket/collects/compiler/private/compiled/winutf16_rkt.zo
share/racket/collects/compiler/private/compiled/xform_rkt.dep
share/racket/collects/compiler/private/compiled/xform_rkt.zo
share/racket/collects/compiler/private/configdir.rkt
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?)
2015-08-05 23:14:29 +02:00
share/racket/collects/compiler/private/dep.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/compiler/private/elf.rkt
share/racket/collects/compiler/private/embed.rkt
share/racket/collects/compiler/private/macfw.rkt
share/racket/collects/compiler/private/mach-o.rkt
share/racket/collects/compiler/private/windlldir.rkt
share/racket/collects/compiler/private/winsubsys.rkt
share/racket/collects/compiler/private/winutf16.rkt
share/racket/collects/compiler/private/xform.rkt
share/racket/collects/data/bit-vector.rkt
share/racket/collects/data/compiled/bit-vector_rkt.dep
share/racket/collects/data/compiled/bit-vector_rkt.zo
share/racket/collects/data/compiled/integer-set_rkt.dep
share/racket/collects/data/compiled/integer-set_rkt.zo
share/racket/collects/data/compiled/queue_rkt.dep
share/racket/collects/data/compiled/queue_rkt.zo
share/racket/collects/data/integer-set.rkt
share/racket/collects/data/private/compiled/count-bits-in-fixnum_rkt.dep
share/racket/collects/data/private/compiled/count-bits-in-fixnum_rkt.zo
share/racket/collects/data/private/count-bits-in-fixnum.rkt
share/racket/collects/data/queue.rkt
share/racket/collects/db/private/compiled/pre_rkt.dep
share/racket/collects/db/private/compiled/pre_rkt.zo
share/racket/collects/db/private/generic/common.rkt
share/racket/collects/db/private/generic/compiled/common_rkt.dep
share/racket/collects/db/private/generic/compiled/common_rkt.zo
share/racket/collects/db/private/generic/compiled/functions_rkt.dep
share/racket/collects/db/private/generic/compiled/functions_rkt.zo
share/racket/collects/db/private/generic/compiled/interfaces_rkt.dep
share/racket/collects/db/private/generic/compiled/interfaces_rkt.zo
share/racket/collects/db/private/generic/compiled/prepared_rkt.dep
share/racket/collects/db/private/generic/compiled/prepared_rkt.zo
share/racket/collects/db/private/generic/compiled/sql-data_rkt.dep
share/racket/collects/db/private/generic/compiled/sql-data_rkt.zo
share/racket/collects/db/private/generic/functions.rkt
share/racket/collects/db/private/generic/interfaces.rkt
share/racket/collects/db/private/generic/prepared.rkt
share/racket/collects/db/private/generic/sql-data.rkt
share/racket/collects/db/private/pre.rkt
share/racket/collects/db/private/sqlite3/compiled/connection_rkt.dep
share/racket/collects/db/private/sqlite3/compiled/connection_rkt.zo
share/racket/collects/db/private/sqlite3/compiled/dbsystem_rkt.dep
share/racket/collects/db/private/sqlite3/compiled/dbsystem_rkt.zo
share/racket/collects/db/private/sqlite3/compiled/ffi-constants_rkt.dep
share/racket/collects/db/private/sqlite3/compiled/ffi-constants_rkt.zo
share/racket/collects/db/private/sqlite3/compiled/ffi_rkt.dep
share/racket/collects/db/private/sqlite3/compiled/ffi_rkt.zo
share/racket/collects/db/private/sqlite3/compiled/main_rkt.dep
share/racket/collects/db/private/sqlite3/compiled/main_rkt.zo
share/racket/collects/db/private/sqlite3/connection.rkt
share/racket/collects/db/private/sqlite3/dbsystem.rkt
share/racket/collects/db/private/sqlite3/ffi-constants.rkt
share/racket/collects/db/private/sqlite3/ffi.rkt
share/racket/collects/db/private/sqlite3/main.rkt
share/racket/collects/dynext/compiled/file_rkt.dep
share/racket/collects/dynext/compiled/file_rkt.zo
share/racket/collects/dynext/compiled/filename-version_rkt.dep
share/racket/collects/dynext/compiled/filename-version_rkt.zo
share/racket/collects/dynext/file.rkt
share/racket/collects/dynext/filename-version.rkt
share/racket/collects/ffi/com-registry.rkt
share/racket/collects/ffi/com.rkt
share/racket/collects/ffi/compiled/com-registry_rkt.dep
share/racket/collects/ffi/compiled/com-registry_rkt.zo
share/racket/collects/ffi/compiled/com_rkt.dep
share/racket/collects/ffi/compiled/com_rkt.zo
share/racket/collects/ffi/compiled/cvector_rkt.dep
share/racket/collects/ffi/compiled/cvector_rkt.zo
share/racket/collects/ffi/compiled/file_rkt.dep
share/racket/collects/ffi/compiled/file_rkt.zo
share/racket/collects/ffi/compiled/objc_rkt.dep
share/racket/collects/ffi/compiled/objc_rkt.zo
share/racket/collects/ffi/compiled/unsafe_rkt.dep
share/racket/collects/ffi/compiled/unsafe_rkt.zo
share/racket/collects/ffi/compiled/vector_rkt.dep
share/racket/collects/ffi/compiled/vector_rkt.zo
share/racket/collects/ffi/compiled/winapi_rkt.dep
share/racket/collects/ffi/compiled/winapi_rkt.zo
share/racket/collects/ffi/cvector.rkt
share/racket/collects/ffi/file.rkt
share/racket/collects/ffi/objc.rkt
share/racket/collects/ffi/unsafe.rkt
share/racket/collects/ffi/unsafe/alloc.rkt
share/racket/collects/ffi/unsafe/atomic.rkt
share/racket/collects/ffi/unsafe/com.rkt
share/racket/collects/ffi/unsafe/compiled/alloc_rkt.dep
share/racket/collects/ffi/unsafe/compiled/alloc_rkt.zo
share/racket/collects/ffi/unsafe/compiled/atomic_rkt.dep
share/racket/collects/ffi/unsafe/compiled/atomic_rkt.zo
share/racket/collects/ffi/unsafe/compiled/com_rkt.dep
share/racket/collects/ffi/unsafe/compiled/com_rkt.zo
share/racket/collects/ffi/unsafe/compiled/custodian_rkt.dep
share/racket/collects/ffi/unsafe/compiled/custodian_rkt.zo
share/racket/collects/ffi/unsafe/compiled/cvector_rkt.dep
share/racket/collects/ffi/unsafe/compiled/cvector_rkt.zo
share/racket/collects/ffi/unsafe/compiled/define_rkt.dep
share/racket/collects/ffi/unsafe/compiled/define_rkt.zo
share/racket/collects/ffi/unsafe/compiled/nsalloc_rkt.dep
share/racket/collects/ffi/unsafe/compiled/nsalloc_rkt.zo
share/racket/collects/ffi/unsafe/compiled/nsstring_rkt.dep
share/racket/collects/ffi/unsafe/compiled/nsstring_rkt.zo
share/racket/collects/ffi/unsafe/compiled/objc_rkt.dep
share/racket/collects/ffi/unsafe/compiled/objc_rkt.zo
share/racket/collects/ffi/unsafe/compiled/try-atomic_rkt.dep
share/racket/collects/ffi/unsafe/compiled/try-atomic_rkt.zo
share/racket/collects/ffi/unsafe/custodian.rkt
share/racket/collects/ffi/unsafe/cvector.rkt
share/racket/collects/ffi/unsafe/define.rkt
share/racket/collects/ffi/unsafe/nsalloc.rkt
share/racket/collects/ffi/unsafe/nsstring.rkt
share/racket/collects/ffi/unsafe/objc.rkt
share/racket/collects/ffi/unsafe/private/compiled/win32_rkt.dep
share/racket/collects/ffi/unsafe/private/compiled/win32_rkt.zo
share/racket/collects/ffi/unsafe/private/win32.rkt
share/racket/collects/ffi/unsafe/try-atomic.rkt
share/racket/collects/ffi/vector.rkt
share/racket/collects/ffi/winapi.rkt
share/racket/collects/file/cache.rkt
share/racket/collects/file/compiled/cache_rkt.dep
share/racket/collects/file/compiled/cache_rkt.zo
share/racket/collects/file/compiled/convertible_rkt.dep
share/racket/collects/file/compiled/convertible_rkt.zo
share/racket/collects/file/compiled/gunzip_rkt.dep
share/racket/collects/file/compiled/gunzip_rkt.zo
share/racket/collects/file/compiled/gzip_rkt.dep
share/racket/collects/file/compiled/gzip_rkt.zo
share/racket/collects/file/compiled/ico_rkt.dep
share/racket/collects/file/compiled/ico_rkt.zo
share/racket/collects/file/compiled/md5_rkt.dep
share/racket/collects/file/compiled/md5_rkt.zo
share/racket/collects/file/compiled/resource_rkt.dep
share/racket/collects/file/compiled/resource_rkt.zo
share/racket/collects/file/compiled/sha1_rkt.dep
share/racket/collects/file/compiled/sha1_rkt.zo
share/racket/collects/file/compiled/tar_rkt.dep
share/racket/collects/file/compiled/tar_rkt.zo
share/racket/collects/file/compiled/untar_rkt.dep
share/racket/collects/file/compiled/untar_rkt.zo
share/racket/collects/file/compiled/untgz_rkt.dep
share/racket/collects/file/compiled/untgz_rkt.zo
share/racket/collects/file/compiled/unzip_rkt.dep
share/racket/collects/file/compiled/unzip_rkt.zo
share/racket/collects/file/compiled/zip_rkt.dep
share/racket/collects/file/compiled/zip_rkt.zo
share/racket/collects/file/convertible.rkt
share/racket/collects/file/gunzip.rkt
share/racket/collects/file/gzip.rkt
share/racket/collects/file/ico.rkt
share/racket/collects/file/md5.rkt
share/racket/collects/file/private/compiled/strip-prefix_rkt.dep
share/racket/collects/file/private/compiled/strip-prefix_rkt.zo
share/racket/collects/file/private/strip-prefix.rkt
share/racket/collects/file/resource.rkt
share/racket/collects/file/sha1.rkt
share/racket/collects/file/tar.rkt
share/racket/collects/file/untar.rkt
share/racket/collects/file/untgz.rkt
share/racket/collects/file/unzip.rkt
share/racket/collects/file/zip.rkt
share/racket/collects/info-domain/compiled/cache.rktd
share/racket/collects/info/compiled/main_rkt.dep
share/racket/collects/info/compiled/main_rkt.zo
share/racket/collects/info/main.rkt
share/racket/collects/json/compiled/main_rkt.dep
share/racket/collects/json/compiled/main_rkt.zo
share/racket/collects/json/main.rkt
share/racket/collects/launcher/compiled/info_rkt.dep
share/racket/collects/launcher/compiled/info_rkt.zo
share/racket/collects/launcher/compiled/launcher_rkt.dep
share/racket/collects/launcher/compiled/launcher_rkt.zo
share/racket/collects/launcher/compiled/main_rkt.dep
share/racket/collects/launcher/compiled/main_rkt.zo
share/racket/collects/launcher/info.rkt
share/racket/collects/launcher/launcher.rkt
share/racket/collects/launcher/main.rkt
share/racket/collects/net/base64.rkt
share/racket/collects/net/compiled/base64_rkt.dep
share/racket/collects/net/compiled/base64_rkt.zo
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?)
2015-08-05 23:14:29 +02:00
share/racket/collects/net/compiled/git-checkout_rkt.dep
share/racket/collects/net/compiled/git-checkout_rkt.zo
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/net/compiled/head_rkt.dep
share/racket/collects/net/compiled/head_rkt.zo
share/racket/collects/net/compiled/http-client_rkt.dep
share/racket/collects/net/compiled/http-client_rkt.zo
share/racket/collects/net/compiled/uri-codec_rkt.dep
share/racket/collects/net/compiled/uri-codec_rkt.zo
share/racket/collects/net/compiled/url-connect_rkt.dep
share/racket/collects/net/compiled/url-connect_rkt.zo
share/racket/collects/net/compiled/url-structs_rkt.dep
share/racket/collects/net/compiled/url-structs_rkt.zo
share/racket/collects/net/compiled/url_rkt.dep
share/racket/collects/net/compiled/url_rkt.zo
share/racket/collects/net/compiled/win32-ssl_rkt.dep
share/racket/collects/net/compiled/win32-ssl_rkt.zo
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?)
2015-08-05 23:14:29 +02:00
share/racket/collects/net/git-checkout.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/net/head.rkt
share/racket/collects/net/http-client.rkt
share/racket/collects/net/uri-codec.rkt
share/racket/collects/net/url-connect.rkt
share/racket/collects/net/url-structs.rkt
share/racket/collects/net/url.rkt
share/racket/collects/net/win32-ssl.rkt
share/racket/collects/openssl/compiled/libcrypto_rkt.dep
share/racket/collects/openssl/compiled/libcrypto_rkt.zo
share/racket/collects/openssl/compiled/libssl_rkt.dep
share/racket/collects/openssl/compiled/libssl_rkt.zo
share/racket/collects/openssl/compiled/main_rkt.dep
share/racket/collects/openssl/compiled/main_rkt.zo
share/racket/collects/openssl/compiled/md5_rkt.dep
share/racket/collects/openssl/compiled/md5_rkt.zo
share/racket/collects/openssl/compiled/mzssl_rkt.dep
share/racket/collects/openssl/compiled/mzssl_rkt.zo
share/racket/collects/openssl/compiled/openssl_rkt.dep
share/racket/collects/openssl/compiled/openssl_rkt.zo
share/racket/collects/openssl/compiled/sha1_rkt.dep
share/racket/collects/openssl/compiled/sha1_rkt.zo
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/openssl/dh4096.pem
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/openssl/libcrypto.rkt
share/racket/collects/openssl/libssl.rkt
share/racket/collects/openssl/main.rkt
share/racket/collects/openssl/md5.rkt
share/racket/collects/openssl/mzssl.rkt
share/racket/collects/openssl/openssl.rkt
share/racket/collects/openssl/private/add-cert.rkt
share/racket/collects/openssl/private/compiled/add-cert_rkt.dep
share/racket/collects/openssl/private/compiled/add-cert_rkt.zo
share/racket/collects/openssl/private/compiled/macosx_rkt.dep
share/racket/collects/openssl/private/compiled/macosx_rkt.zo
share/racket/collects/openssl/private/compiled/win32_rkt.dep
share/racket/collects/openssl/private/compiled/win32_rkt.zo
share/racket/collects/openssl/private/macosx.rkt
share/racket/collects/openssl/private/win32.rkt
share/racket/collects/openssl/sha1.rkt
share/racket/collects/openssl/test.pem
share/racket/collects/pkg/commands.rkt
share/racket/collects/pkg/compiled/commands_rkt.dep
share/racket/collects/pkg/compiled/commands_rkt.zo
share/racket/collects/pkg/compiled/db_rkt.dep
share/racket/collects/pkg/compiled/db_rkt.zo
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?)
2015-08-05 23:14:29 +02:00
share/racket/collects/pkg/compiled/dirs-catalog_rkt.dep
share/racket/collects/pkg/compiled/dirs-catalog_rkt.zo
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/pkg/compiled/info_rkt.dep
share/racket/collects/pkg/compiled/info_rkt.zo
share/racket/collects/pkg/compiled/lib_rkt.dep
share/racket/collects/pkg/compiled/lib_rkt.zo
share/racket/collects/pkg/compiled/main_rkt.dep
share/racket/collects/pkg/compiled/main_rkt.zo
share/racket/collects/pkg/compiled/name_rkt.dep
share/racket/collects/pkg/compiled/name_rkt.zo
share/racket/collects/pkg/compiled/path_rkt.dep
share/racket/collects/pkg/compiled/path_rkt.zo
share/racket/collects/pkg/compiled/raco_rkt.dep
share/racket/collects/pkg/compiled/raco_rkt.zo
share/racket/collects/pkg/compiled/strip_rkt.dep
share/racket/collects/pkg/compiled/strip_rkt.zo
share/racket/collects/pkg/db.rkt
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?)
2015-08-05 23:14:29 +02:00
share/racket/collects/pkg/dirs-catalog.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/pkg/info.rkt
share/racket/collects/pkg/lib.rkt
share/racket/collects/pkg/main.rkt
share/racket/collects/pkg/name.rkt
share/racket/collects/pkg/path.rkt
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?)
2015-08-05 23:14:29 +02:00
share/racket/collects/pkg/private/addl-installs.rkt
share/racket/collects/pkg/private/archive.rkt
share/racket/collects/pkg/private/catalog-archive.rkt
share/racket/collects/pkg/private/catalog-copy.rkt
share/racket/collects/pkg/private/catalog-show.rkt
share/racket/collects/pkg/private/catalog-update.rkt
share/racket/collects/pkg/private/catalog.rkt
share/racket/collects/pkg/private/clone-path.rkt
share/racket/collects/pkg/private/collects.rkt
share/racket/collects/pkg/private/compiled/addl-installs_rkt.dep
share/racket/collects/pkg/private/compiled/addl-installs_rkt.zo
share/racket/collects/pkg/private/compiled/archive_rkt.dep
share/racket/collects/pkg/private/compiled/archive_rkt.zo
share/racket/collects/pkg/private/compiled/catalog-archive_rkt.dep
share/racket/collects/pkg/private/compiled/catalog-archive_rkt.zo
share/racket/collects/pkg/private/compiled/catalog-copy_rkt.dep
share/racket/collects/pkg/private/compiled/catalog-copy_rkt.zo
share/racket/collects/pkg/private/compiled/catalog-show_rkt.dep
share/racket/collects/pkg/private/compiled/catalog-show_rkt.zo
share/racket/collects/pkg/private/compiled/catalog-update_rkt.dep
share/racket/collects/pkg/private/compiled/catalog-update_rkt.zo
share/racket/collects/pkg/private/compiled/catalog_rkt.dep
share/racket/collects/pkg/private/compiled/catalog_rkt.zo
share/racket/collects/pkg/private/compiled/clone-path_rkt.dep
share/racket/collects/pkg/private/compiled/clone-path_rkt.zo
share/racket/collects/pkg/private/compiled/collects_rkt.dep
share/racket/collects/pkg/private/compiled/collects_rkt.zo
share/racket/collects/pkg/private/compiled/config_rkt.dep
share/racket/collects/pkg/private/compiled/config_rkt.zo
share/racket/collects/pkg/private/compiled/content_rkt.dep
share/racket/collects/pkg/private/compiled/content_rkt.zo
share/racket/collects/pkg/private/compiled/create_rkt.dep
share/racket/collects/pkg/private/compiled/create_rkt.zo
share/racket/collects/pkg/private/compiled/dep_rkt.dep
share/racket/collects/pkg/private/compiled/dep_rkt.zo
share/racket/collects/pkg/private/compiled/desc_rkt.dep
share/racket/collects/pkg/private/compiled/desc_rkt.zo
share/racket/collects/pkg/private/compiled/dirs_rkt.dep
share/racket/collects/pkg/private/compiled/dirs_rkt.zo
share/racket/collects/pkg/private/compiled/download_rkt.dep
share/racket/collects/pkg/private/compiled/download_rkt.zo
share/racket/collects/pkg/private/compiled/get-info_rkt.dep
share/racket/collects/pkg/private/compiled/get-info_rkt.zo
share/racket/collects/pkg/private/compiled/git_rkt.dep
share/racket/collects/pkg/private/compiled/git_rkt.zo
share/racket/collects/pkg/private/compiled/info-to-desc_rkt.dep
share/racket/collects/pkg/private/compiled/info-to-desc_rkt.zo
share/racket/collects/pkg/private/compiled/install_rkt.dep
share/racket/collects/pkg/private/compiled/install_rkt.zo
share/racket/collects/pkg/private/compiled/lock_rkt.dep
share/racket/collects/pkg/private/compiled/lock_rkt.zo
share/racket/collects/pkg/private/compiled/metadata_rkt.dep
share/racket/collects/pkg/private/compiled/metadata_rkt.zo
share/racket/collects/pkg/private/compiled/migrate_rkt.dep
share/racket/collects/pkg/private/compiled/migrate_rkt.zo
share/racket/collects/pkg/private/compiled/mod-paths_rkt.dep
share/racket/collects/pkg/private/compiled/mod-paths_rkt.zo
share/racket/collects/pkg/private/compiled/new_rkt.dep
share/racket/collects/pkg/private/compiled/new_rkt.zo
share/racket/collects/pkg/private/compiled/orig-pkg_rkt.dep
share/racket/collects/pkg/private/compiled/orig-pkg_rkt.zo
share/racket/collects/pkg/private/compiled/params_rkt.dep
share/racket/collects/pkg/private/compiled/params_rkt.zo
share/racket/collects/pkg/private/compiled/path_rkt.dep
share/racket/collects/pkg/private/compiled/path_rkt.zo
share/racket/collects/pkg/private/compiled/pkg-db_rkt.dep
share/racket/collects/pkg/private/compiled/pkg-db_rkt.zo
share/racket/collects/pkg/private/compiled/print_rkt.dep
share/racket/collects/pkg/private/compiled/print_rkt.zo
share/racket/collects/pkg/private/compiled/remove_rkt.dep
share/racket/collects/pkg/private/compiled/remove_rkt.zo
share/racket/collects/pkg/private/compiled/repo-path_rkt.dep
share/racket/collects/pkg/private/compiled/repo-path_rkt.zo
share/racket/collects/pkg/private/compiled/show_rkt.dep
share/racket/collects/pkg/private/compiled/show_rkt.zo
share/racket/collects/pkg/private/compiled/stage_rkt.dep
share/racket/collects/pkg/private/compiled/stage_rkt.zo
share/racket/collects/pkg/private/compiled/suggestions_rkt.dep
share/racket/collects/pkg/private/compiled/suggestions_rkt.zo
share/racket/collects/pkg/private/compiled/trash_rkt.dep
share/racket/collects/pkg/private/compiled/trash_rkt.zo
share/racket/collects/pkg/private/config.rkt
share/racket/collects/pkg/private/content.rkt
share/racket/collects/pkg/private/create.rkt
share/racket/collects/pkg/private/dep.rkt
share/racket/collects/pkg/private/desc.rkt
share/racket/collects/pkg/private/dirs.rkt
share/racket/collects/pkg/private/download.rkt
share/racket/collects/pkg/private/get-info.rkt
share/racket/collects/pkg/private/git.rkt
share/racket/collects/pkg/private/info-to-desc.rkt
share/racket/collects/pkg/private/install.rkt
share/racket/collects/pkg/private/lock.rkt
share/racket/collects/pkg/private/metadata.rkt
share/racket/collects/pkg/private/migrate.rkt
share/racket/collects/pkg/private/mod-paths.rkt
share/racket/collects/pkg/private/new.rkt
share/racket/collects/pkg/private/orig-pkg.rkt
share/racket/collects/pkg/private/params.rkt
share/racket/collects/pkg/private/path.rkt
share/racket/collects/pkg/private/pkg-db.rkt
share/racket/collects/pkg/private/print.rkt
share/racket/collects/pkg/private/remove.rkt
share/racket/collects/pkg/private/repo-path.rkt
share/racket/collects/pkg/private/show.rkt
share/racket/collects/pkg/private/stage.rkt
share/racket/collects/pkg/private/suggestions.rkt
share/racket/collects/pkg/private/trash.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/pkg/raco.rkt
share/racket/collects/pkg/strip.rkt
share/racket/collects/planet/cachepath.rkt
share/racket/collects/planet/compiled/cachepath_rkt.dep
share/racket/collects/planet/compiled/cachepath_rkt.zo
share/racket/collects/planet/compiled/config_rkt.dep
share/racket/collects/planet/compiled/config_rkt.zo
share/racket/collects/planet/compiled/planet-archives_rkt.dep
share/racket/collects/planet/compiled/planet-archives_rkt.zo
share/racket/collects/planet/compiled/resolver_rkt.dep
share/racket/collects/planet/compiled/resolver_rkt.zo
share/racket/collects/planet/compiled/terse-info_rkt.dep
share/racket/collects/planet/compiled/terse-info_rkt.zo
share/racket/collects/planet/config.rkt
share/racket/collects/planet/planet-archives.rkt
share/racket/collects/planet/private/command.rkt
share/racket/collects/planet/private/compiled/command_rkt.dep
share/racket/collects/planet/private/compiled/command_rkt.zo
share/racket/collects/planet/private/compiled/data_rkt.dep
share/racket/collects/planet/private/compiled/data_rkt.zo
share/racket/collects/planet/private/compiled/define-config_rkt.dep
share/racket/collects/planet/private/compiled/define-config_rkt.zo
share/racket/collects/planet/private/compiled/linkage_rkt.dep
share/racket/collects/planet/private/compiled/linkage_rkt.zo
share/racket/collects/planet/private/compiled/parsereq_rkt.dep
share/racket/collects/planet/private/compiled/parsereq_rkt.zo
share/racket/collects/planet/private/compiled/planet-shared_rkt.dep
share/racket/collects/planet/private/compiled/planet-shared_rkt.zo
share/racket/collects/planet/private/compiled/prefix-dispatcher_rkt.dep
share/racket/collects/planet/private/compiled/prefix-dispatcher_rkt.zo
share/racket/collects/planet/private/compiled/resolver_rkt.dep
share/racket/collects/planet/private/compiled/resolver_rkt.zo
share/racket/collects/planet/private/compiled/short-syntax-helpers_rkt.dep
share/racket/collects/planet/private/compiled/short-syntax-helpers_rkt.zo
share/racket/collects/planet/private/data.rkt
share/racket/collects/planet/private/define-config.rkt
share/racket/collects/planet/private/linkage.rkt
share/racket/collects/planet/private/parsereq.rkt
share/racket/collects/planet/private/planet-shared.rkt
share/racket/collects/planet/private/prefix-dispatcher.rkt
share/racket/collects/planet/private/resolver.rkt
share/racket/collects/planet/private/short-syntax-helpers.rkt
share/racket/collects/planet/resolver.rkt
share/racket/collects/planet/terse-info.rkt
share/racket/collects/racket/HISTORY.txt
share/racket/collects/racket/MzScheme_200.txt
share/racket/collects/racket/MzScheme_300.txt
share/racket/collects/racket/MzScheme_4.txt
share/racket/collects/racket/Racket_5.txt
share/racket/collects/racket/async-channel.rkt
share/racket/collects/racket/base.rkt
share/racket/collects/racket/base/lang/compiled/reader_rkt.dep
share/racket/collects/racket/base/lang/compiled/reader_rkt.zo
share/racket/collects/racket/base/lang/reader.rkt
share/racket/collects/racket/block.rkt
share/racket/collects/racket/bool.rkt
share/racket/collects/racket/bytes.rkt
share/racket/collects/racket/class.rkt
share/racket/collects/racket/cmdline.rkt
share/racket/collects/racket/compiled/async-channel_rkt.dep
share/racket/collects/racket/compiled/async-channel_rkt.zo
share/racket/collects/racket/compiled/base_rkt.dep
share/racket/collects/racket/compiled/base_rkt.zo
share/racket/collects/racket/compiled/block_rkt.dep
share/racket/collects/racket/compiled/block_rkt.zo
share/racket/collects/racket/compiled/bool_rkt.dep
share/racket/collects/racket/compiled/bool_rkt.zo
share/racket/collects/racket/compiled/bytes_rkt.dep
share/racket/collects/racket/compiled/bytes_rkt.zo
share/racket/collects/racket/compiled/class_rkt.dep
share/racket/collects/racket/compiled/class_rkt.zo
share/racket/collects/racket/compiled/cmdline_rkt.dep
share/racket/collects/racket/compiled/cmdline_rkt.zo
share/racket/collects/racket/compiled/contract_rkt.dep
share/racket/collects/racket/compiled/contract_rkt.zo
share/racket/collects/racket/compiled/control_rkt.dep
share/racket/collects/racket/compiled/control_rkt.zo
share/racket/collects/racket/compiled/date_rkt.dep
share/racket/collects/racket/compiled/date_rkt.zo
share/racket/collects/racket/compiled/dict_rkt.dep
share/racket/collects/racket/compiled/dict_rkt.zo
share/racket/collects/racket/compiled/engine_rkt.dep
share/racket/collects/racket/compiled/engine_rkt.zo
share/racket/collects/racket/compiled/enter_rkt.dep
share/racket/collects/racket/compiled/enter_rkt.zo
share/racket/collects/racket/compiled/extflonum_rkt.dep
share/racket/collects/racket/compiled/extflonum_rkt.zo
share/racket/collects/racket/compiled/fasl_rkt.dep
share/racket/collects/racket/compiled/fasl_rkt.zo
share/racket/collects/racket/compiled/file_rkt.dep
share/racket/collects/racket/compiled/file_rkt.zo
share/racket/collects/racket/compiled/fixnum_rkt.dep
share/racket/collects/racket/compiled/fixnum_rkt.zo
share/racket/collects/racket/compiled/flonum_rkt.dep
share/racket/collects/racket/compiled/flonum_rkt.zo
share/racket/collects/racket/compiled/format_rkt.dep
share/racket/collects/racket/compiled/format_rkt.zo
share/racket/collects/racket/compiled/function_rkt.dep
share/racket/collects/racket/compiled/function_rkt.zo
share/racket/collects/racket/compiled/future_rkt.dep
share/racket/collects/racket/compiled/future_rkt.zo
share/racket/collects/racket/compiled/generator_rkt.dep
share/racket/collects/racket/compiled/generator_rkt.zo
share/racket/collects/racket/compiled/generic_rkt.dep
share/racket/collects/racket/compiled/generic_rkt.zo
share/racket/collects/racket/compiled/help_rkt.dep
share/racket/collects/racket/compiled/help_rkt.zo
share/racket/collects/racket/compiled/include_rkt.dep
share/racket/collects/racket/compiled/include_rkt.zo
share/racket/collects/racket/compiled/info_rkt.dep
share/racket/collects/racket/compiled/info_rkt.zo
share/racket/collects/racket/compiled/init_rkt.dep
share/racket/collects/racket/compiled/init_rkt.zo
share/racket/collects/racket/compiled/kernel_rkt.dep
share/racket/collects/racket/compiled/kernel_rkt.zo
share/racket/collects/racket/compiled/keyword-transform_rkt.dep
share/racket/collects/racket/compiled/keyword-transform_rkt.zo
share/racket/collects/racket/compiled/language-info_rkt.dep
share/racket/collects/racket/compiled/language-info_rkt.zo
share/racket/collects/racket/compiled/lazy-require_rkt.dep
share/racket/collects/racket/compiled/lazy-require_rkt.zo
share/racket/collects/racket/compiled/list_rkt.dep
share/racket/collects/racket/compiled/list_rkt.zo
share/racket/collects/racket/compiled/load_rkt.dep
share/racket/collects/racket/compiled/load_rkt.zo
share/racket/collects/racket/compiled/local_rkt.dep
share/racket/collects/racket/compiled/local_rkt.zo
share/racket/collects/racket/compiled/main_rkt.dep
share/racket/collects/racket/compiled/main_rkt.zo
share/racket/collects/racket/compiled/match_rkt.dep
share/racket/collects/racket/compiled/match_rkt.zo
share/racket/collects/racket/compiled/math_rkt.dep
share/racket/collects/racket/compiled/math_rkt.zo
share/racket/collects/racket/compiled/path_rkt.dep
share/racket/collects/racket/compiled/path_rkt.zo
share/racket/collects/racket/compiled/performance-hint_rkt.dep
share/racket/collects/racket/compiled/performance-hint_rkt.zo
share/racket/collects/racket/compiled/place_rkt.dep
share/racket/collects/racket/compiled/place_rkt.zo
share/racket/collects/racket/compiled/port_rkt.dep
share/racket/collects/racket/compiled/port_rkt.zo
share/racket/collects/racket/compiled/pretty_rkt.dep
share/racket/collects/racket/compiled/pretty_rkt.zo
share/racket/collects/racket/compiled/promise_rkt.dep
share/racket/collects/racket/compiled/promise_rkt.zo
share/racket/collects/racket/compiled/provide-syntax_rkt.dep
share/racket/collects/racket/compiled/provide-syntax_rkt.zo
share/racket/collects/racket/compiled/provide-transform_rkt.dep
share/racket/collects/racket/compiled/provide-transform_rkt.zo
share/racket/collects/racket/compiled/provide_rkt.dep
share/racket/collects/racket/compiled/provide_rkt.zo
share/racket/collects/racket/compiled/require-syntax_rkt.dep
share/racket/collects/racket/compiled/require-syntax_rkt.zo
share/racket/collects/racket/compiled/require-transform_rkt.dep
share/racket/collects/racket/compiled/require-transform_rkt.zo
share/racket/collects/racket/compiled/require_rkt.dep
share/racket/collects/racket/compiled/require_rkt.zo
share/racket/collects/racket/compiled/rerequire_rkt.dep
share/racket/collects/racket/compiled/rerequire_rkt.zo
share/racket/collects/racket/compiled/runtime-config_rkt.dep
share/racket/collects/racket/compiled/runtime-config_rkt.zo
share/racket/collects/racket/compiled/runtime-path_rkt.dep
share/racket/collects/racket/compiled/runtime-path_rkt.zo
share/racket/collects/racket/compiled/sequence_rkt.dep
share/racket/collects/racket/compiled/sequence_rkt.zo
share/racket/collects/racket/compiled/serialize_rkt.dep
share/racket/collects/racket/compiled/serialize_rkt.zo
share/racket/collects/racket/compiled/set_rkt.dep
share/racket/collects/racket/compiled/set_rkt.zo
share/racket/collects/racket/compiled/shared_rkt.dep
share/racket/collects/racket/compiled/shared_rkt.zo
share/racket/collects/racket/compiled/splicing_rkt.dep
share/racket/collects/racket/compiled/splicing_rkt.zo
share/racket/collects/racket/compiled/stream_rkt.dep
share/racket/collects/racket/compiled/stream_rkt.zo
share/racket/collects/racket/compiled/string_rkt.dep
share/racket/collects/racket/compiled/string_rkt.zo
share/racket/collects/racket/compiled/struct-info_rkt.dep
share/racket/collects/racket/compiled/struct-info_rkt.zo
share/racket/collects/racket/compiled/stxparam-exptime_rkt.dep
share/racket/collects/racket/compiled/stxparam-exptime_rkt.zo
share/racket/collects/racket/compiled/stxparam_rkt.dep
share/racket/collects/racket/compiled/stxparam_rkt.zo
share/racket/collects/racket/compiled/surrogate_rkt.dep
share/racket/collects/racket/compiled/surrogate_rkt.zo
share/racket/collects/racket/compiled/syntax_rkt.dep
share/racket/collects/racket/compiled/syntax_rkt.zo
share/racket/collects/racket/compiled/system_rkt.dep
share/racket/collects/racket/compiled/system_rkt.zo
share/racket/collects/racket/compiled/tcp_rkt.dep
share/racket/collects/racket/compiled/tcp_rkt.zo
share/racket/collects/racket/compiled/trace_rkt.dep
share/racket/collects/racket/compiled/trace_rkt.zo
share/racket/collects/racket/compiled/trait_rkt.dep
share/racket/collects/racket/compiled/trait_rkt.zo
share/racket/collects/racket/compiled/udp_rkt.dep
share/racket/collects/racket/compiled/udp_rkt.zo
share/racket/collects/racket/compiled/undefined_rkt.dep
share/racket/collects/racket/compiled/undefined_rkt.zo
share/racket/collects/racket/compiled/unit-exptime_rkt.dep
share/racket/collects/racket/compiled/unit-exptime_rkt.zo
share/racket/collects/racket/compiled/unit_rkt.dep
share/racket/collects/racket/compiled/unit_rkt.zo
share/racket/collects/racket/compiled/vector_rkt.dep
share/racket/collects/racket/compiled/vector_rkt.zo
share/racket/collects/racket/contract.rkt
share/racket/collects/racket/contract/base.rkt
share/racket/collects/racket/contract/combinator.rkt
share/racket/collects/racket/contract/compiled/base_rkt.dep
share/racket/collects/racket/contract/compiled/base_rkt.zo
share/racket/collects/racket/contract/compiled/combinator_rkt.dep
share/racket/collects/racket/contract/compiled/combinator_rkt.zo
share/racket/collects/racket/contract/compiled/parametric_rkt.dep
share/racket/collects/racket/contract/compiled/parametric_rkt.zo
share/racket/collects/racket/contract/compiled/region_rkt.dep
share/racket/collects/racket/contract/compiled/region_rkt.zo
share/racket/collects/racket/contract/parametric.rkt
share/racket/collects/racket/contract/private/application-arity-checking.rkt
share/racket/collects/racket/contract/private/arity-checking.rkt
share/racket/collects/racket/contract/private/arr-i-parse.rkt
share/racket/collects/racket/contract/private/arr-i.rkt
share/racket/collects/racket/contract/private/arr-util.rkt
share/racket/collects/racket/contract/private/arrow-higher-order.rkt
share/racket/collects/racket/contract/private/arrow-val-first.rkt
share/racket/collects/racket/contract/private/arrow.rkt
share/racket/collects/racket/contract/private/base.rkt
share/racket/collects/racket/contract/private/basic-opters.rkt
share/racket/collects/racket/contract/private/blame.rkt
share/racket/collects/racket/contract/private/box.rkt
share/racket/collects/racket/contract/private/case-arrow.rkt
share/racket/collects/racket/contract/private/compiled/application-arity-checking_rkt.dep
share/racket/collects/racket/contract/private/compiled/application-arity-checking_rkt.zo
share/racket/collects/racket/contract/private/compiled/arity-checking_rkt.dep
share/racket/collects/racket/contract/private/compiled/arity-checking_rkt.zo
share/racket/collects/racket/contract/private/compiled/arr-i-parse_rkt.dep
share/racket/collects/racket/contract/private/compiled/arr-i-parse_rkt.zo
share/racket/collects/racket/contract/private/compiled/arr-i_rkt.dep
share/racket/collects/racket/contract/private/compiled/arr-i_rkt.zo
share/racket/collects/racket/contract/private/compiled/arr-util_rkt.dep
share/racket/collects/racket/contract/private/compiled/arr-util_rkt.zo
share/racket/collects/racket/contract/private/compiled/arrow-higher-order_rkt.dep
share/racket/collects/racket/contract/private/compiled/arrow-higher-order_rkt.zo
share/racket/collects/racket/contract/private/compiled/arrow-val-first_rkt.dep
share/racket/collects/racket/contract/private/compiled/arrow-val-first_rkt.zo
share/racket/collects/racket/contract/private/compiled/arrow_rkt.dep
share/racket/collects/racket/contract/private/compiled/arrow_rkt.zo
share/racket/collects/racket/contract/private/compiled/base_rkt.dep
share/racket/collects/racket/contract/private/compiled/base_rkt.zo
share/racket/collects/racket/contract/private/compiled/basic-opters_rkt.dep
share/racket/collects/racket/contract/private/compiled/basic-opters_rkt.zo
share/racket/collects/racket/contract/private/compiled/blame_rkt.dep
share/racket/collects/racket/contract/private/compiled/blame_rkt.zo
share/racket/collects/racket/contract/private/compiled/box_rkt.dep
share/racket/collects/racket/contract/private/compiled/box_rkt.zo
share/racket/collects/racket/contract/private/compiled/case-arrow_rkt.dep
share/racket/collects/racket/contract/private/compiled/case-arrow_rkt.zo
share/racket/collects/racket/contract/private/compiled/ds-helpers_rkt.dep
share/racket/collects/racket/contract/private/compiled/ds-helpers_rkt.zo
share/racket/collects/racket/contract/private/compiled/ds_rkt.dep
share/racket/collects/racket/contract/private/compiled/ds_rkt.zo
share/racket/collects/racket/contract/private/compiled/env_rkt.dep
share/racket/collects/racket/contract/private/compiled/env_rkt.zo
share/racket/collects/racket/contract/private/compiled/exists_rkt.dep
share/racket/collects/racket/contract/private/compiled/exists_rkt.zo
share/racket/collects/racket/contract/private/compiled/generate-base_rkt.dep
share/racket/collects/racket/contract/private/compiled/generate-base_rkt.zo
share/racket/collects/racket/contract/private/compiled/generate_rkt.dep
share/racket/collects/racket/contract/private/compiled/generate_rkt.zo
share/racket/collects/racket/contract/private/compiled/guts_rkt.dep
share/racket/collects/racket/contract/private/compiled/guts_rkt.zo
share/racket/collects/racket/contract/private/compiled/hash_rkt.dep
share/racket/collects/racket/contract/private/compiled/hash_rkt.zo
share/racket/collects/racket/contract/private/compiled/helpers_rkt.dep
share/racket/collects/racket/contract/private/compiled/helpers_rkt.zo
share/racket/collects/racket/contract/private/compiled/kwd-info-struct_rkt.dep
share/racket/collects/racket/contract/private/compiled/kwd-info-struct_rkt.zo
share/racket/collects/racket/contract/private/compiled/legacy_rkt.dep
share/racket/collects/racket/contract/private/compiled/legacy_rkt.zo
share/racket/collects/racket/contract/private/compiled/misc_rkt.dep
share/racket/collects/racket/contract/private/compiled/misc_rkt.zo
share/racket/collects/racket/contract/private/compiled/object_rkt.dep
share/racket/collects/racket/contract/private/compiled/object_rkt.zo
share/racket/collects/racket/contract/private/compiled/opt-guts_rkt.dep
share/racket/collects/racket/contract/private/compiled/opt-guts_rkt.zo
share/racket/collects/racket/contract/private/compiled/opt_rkt.dep
share/racket/collects/racket/contract/private/compiled/opt_rkt.zo
share/racket/collects/racket/contract/private/compiled/opters_rkt.dep
share/racket/collects/racket/contract/private/compiled/opters_rkt.zo
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/racket/contract/private/compiled/orc_rkt.dep
share/racket/collects/racket/contract/private/compiled/orc_rkt.zo
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/racket/contract/private/compiled/out_rkt.dep
share/racket/collects/racket/contract/private/compiled/out_rkt.zo
share/racket/collects/racket/contract/private/compiled/parametric_rkt.dep
share/racket/collects/racket/contract/private/compiled/parametric_rkt.zo
share/racket/collects/racket/contract/private/compiled/prop_rkt.dep
share/racket/collects/racket/contract/private/compiled/prop_rkt.zo
share/racket/collects/racket/contract/private/compiled/provide_rkt.dep
share/racket/collects/racket/contract/private/compiled/provide_rkt.zo
share/racket/collects/racket/contract/private/compiled/rand_rkt.dep
share/racket/collects/racket/contract/private/compiled/rand_rkt.zo
share/racket/collects/racket/contract/private/compiled/struct-dc_rkt.dep
share/racket/collects/racket/contract/private/compiled/struct-dc_rkt.zo
share/racket/collects/racket/contract/private/compiled/struct-prop_rkt.dep
share/racket/collects/racket/contract/private/compiled/struct-prop_rkt.zo
share/racket/collects/racket/contract/private/compiled/top-sort_rkt.dep
share/racket/collects/racket/contract/private/compiled/top-sort_rkt.zo
share/racket/collects/racket/contract/private/compiled/vector_rkt.dep
share/racket/collects/racket/contract/private/compiled/vector_rkt.zo
share/racket/collects/racket/contract/private/ds-helpers.rkt
share/racket/collects/racket/contract/private/ds.rkt
share/racket/collects/racket/contract/private/env.rkt
share/racket/collects/racket/contract/private/exists.rkt
share/racket/collects/racket/contract/private/generate-base.rkt
share/racket/collects/racket/contract/private/generate.rkt
share/racket/collects/racket/contract/private/guts.rkt
share/racket/collects/racket/contract/private/hash.rkt
share/racket/collects/racket/contract/private/helpers.rkt
share/racket/collects/racket/contract/private/kwd-info-struct.rkt
share/racket/collects/racket/contract/private/legacy.rkt
share/racket/collects/racket/contract/private/misc.rkt
share/racket/collects/racket/contract/private/object.rkt
share/racket/collects/racket/contract/private/opt-guts.rkt
share/racket/collects/racket/contract/private/opt.rkt
share/racket/collects/racket/contract/private/opters.rkt
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/racket/contract/private/orc.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/racket/contract/private/out.rkt
share/racket/collects/racket/contract/private/parametric.rkt
share/racket/collects/racket/contract/private/prop.rkt
share/racket/collects/racket/contract/private/provide.rkt
share/racket/collects/racket/contract/private/rand.rkt
share/racket/collects/racket/contract/private/struct-dc.rkt
share/racket/collects/racket/contract/private/struct-prop.rkt
share/racket/collects/racket/contract/private/top-sort.rkt
share/racket/collects/racket/contract/private/vector.rkt
share/racket/collects/racket/contract/region.rkt
share/racket/collects/racket/control.rkt
share/racket/collects/racket/date.rkt
share/racket/collects/racket/dict.rkt
share/racket/collects/racket/engine.rkt
share/racket/collects/racket/enter.rkt
share/racket/collects/racket/extflonum.rkt
share/racket/collects/racket/fasl.rkt
share/racket/collects/racket/file.rkt
share/racket/collects/racket/fixnum.rkt
share/racket/collects/racket/flonum.rkt
share/racket/collects/racket/format.rkt
share/racket/collects/racket/function.rkt
share/racket/collects/racket/future.rkt
share/racket/collects/racket/generator.rkt
share/racket/collects/racket/generic.rkt
share/racket/collects/racket/gui/compiled/dynamic_rkt.dep
share/racket/collects/racket/gui/compiled/dynamic_rkt.zo
share/racket/collects/racket/gui/dynamic.rkt
share/racket/collects/racket/help.rkt
share/racket/collects/racket/include.rkt
share/racket/collects/racket/info.rkt
share/racket/collects/racket/init.rkt
share/racket/collects/racket/kernel.rkt
share/racket/collects/racket/kernel/compiled/init_rkt.dep
share/racket/collects/racket/kernel/compiled/init_rkt.zo
share/racket/collects/racket/kernel/init.rkt
share/racket/collects/racket/keyword-transform.rkt
share/racket/collects/racket/lang/compiled/reader_rkt.dep
share/racket/collects/racket/lang/compiled/reader_rkt.zo
share/racket/collects/racket/lang/reader.rkt
share/racket/collects/racket/language-info.rkt
share/racket/collects/racket/lazy-require.rkt
share/racket/collects/racket/list.rkt
share/racket/collects/racket/load.rkt
share/racket/collects/racket/load/lang/compiled/reader_rkt.dep
share/racket/collects/racket/load/lang/compiled/reader_rkt.zo
share/racket/collects/racket/load/lang/reader.rkt
share/racket/collects/racket/local.rkt
share/racket/collects/racket/main.rkt
share/racket/collects/racket/match.rkt
share/racket/collects/racket/match/compiled/compiler_rkt.dep
share/racket/collects/racket/match/compiled/compiler_rkt.zo
share/racket/collects/racket/match/compiled/define-forms_rkt.dep
share/racket/collects/racket/match/compiled/define-forms_rkt.zo
share/racket/collects/racket/match/compiled/gen-match_rkt.dep
share/racket/collects/racket/match/compiled/gen-match_rkt.zo
share/racket/collects/racket/match/compiled/legacy-match_rkt.dep
share/racket/collects/racket/match/compiled/legacy-match_rkt.zo
share/racket/collects/racket/match/compiled/match-expander_rkt.dep
share/racket/collects/racket/match/compiled/match-expander_rkt.zo
share/racket/collects/racket/match/compiled/match_rkt.dep
share/racket/collects/racket/match/compiled/match_rkt.zo
share/racket/collects/racket/match/compiled/parse-helper_rkt.dep
share/racket/collects/racket/match/compiled/parse-helper_rkt.zo
share/racket/collects/racket/match/compiled/parse-legacy_rkt.dep
share/racket/collects/racket/match/compiled/parse-legacy_rkt.zo
share/racket/collects/racket/match/compiled/parse-quasi_rkt.dep
share/racket/collects/racket/match/compiled/parse-quasi_rkt.zo
share/racket/collects/racket/match/compiled/parse_rkt.dep
share/racket/collects/racket/match/compiled/parse_rkt.zo
share/racket/collects/racket/match/compiled/patterns_rkt.dep
share/racket/collects/racket/match/compiled/patterns_rkt.zo
share/racket/collects/racket/match/compiled/reorder_rkt.dep
share/racket/collects/racket/match/compiled/reorder_rkt.zo
share/racket/collects/racket/match/compiled/runtime_rkt.dep
share/racket/collects/racket/match/compiled/runtime_rkt.zo
share/racket/collects/racket/match/compiled/split-rows_rkt.dep
share/racket/collects/racket/match/compiled/split-rows_rkt.zo
share/racket/collects/racket/match/compiled/struct_rkt.dep
share/racket/collects/racket/match/compiled/struct_rkt.zo
share/racket/collects/racket/match/compiled/stxtime_rkt.dep
share/racket/collects/racket/match/compiled/stxtime_rkt.zo
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/racket/match/compiled/syntax-local-match-introduce_rkt.dep
share/racket/collects/racket/match/compiled/syntax-local-match-introduce_rkt.zo
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/racket/match/compiler.rkt
share/racket/collects/racket/match/define-forms.rkt
share/racket/collects/racket/match/gen-match.rkt
share/racket/collects/racket/match/legacy-match.rkt
share/racket/collects/racket/match/match-expander.rkt
share/racket/collects/racket/match/match.rkt
share/racket/collects/racket/match/parse-helper.rkt
share/racket/collects/racket/match/parse-legacy.rkt
share/racket/collects/racket/match/parse-quasi.rkt
share/racket/collects/racket/match/parse.rkt
share/racket/collects/racket/match/patterns.rkt
share/racket/collects/racket/match/reorder.rkt
share/racket/collects/racket/match/runtime.rkt
share/racket/collects/racket/match/split-rows.rkt
share/racket/collects/racket/match/struct.rkt
share/racket/collects/racket/match/stxtime.rkt
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/racket/match/syntax-local-match-introduce.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/racket/math.rkt
share/racket/collects/racket/path.rkt
share/racket/collects/racket/performance-hint.rkt
share/racket/collects/racket/place.rkt
share/racket/collects/racket/place/private/async-bi-channel.rkt
share/racket/collects/racket/place/private/coercion.rkt
share/racket/collects/racket/place/private/compiled/async-bi-channel_rkt.dep
share/racket/collects/racket/place/private/compiled/async-bi-channel_rkt.zo
share/racket/collects/racket/place/private/compiled/coercion_rkt.dep
share/racket/collects/racket/place/private/compiled/coercion_rkt.zo
share/racket/collects/racket/place/private/compiled/prop_rkt.dep
share/racket/collects/racket/place/private/compiled/prop_rkt.zo
share/racket/collects/racket/place/private/compiled/th-place_rkt.dep
share/racket/collects/racket/place/private/compiled/th-place_rkt.zo
share/racket/collects/racket/place/private/prop.rkt
share/racket/collects/racket/place/private/th-place.rkt
share/racket/collects/racket/port.rkt
share/racket/collects/racket/pretty.rkt
share/racket/collects/racket/private/base.rkt
share/racket/collects/racket/private/case.rkt
share/racket/collects/racket/private/cert.rkt
share/racket/collects/racket/private/class-c-new.rkt
share/racket/collects/racket/private/class-c-old.rkt
share/racket/collects/racket/private/class-internal.rkt
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/racket/private/class-undef.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/racket/private/class-wrapped.rkt
share/racket/collects/racket/private/classidmap.rkt
share/racket/collects/racket/private/compiled/base_rkt.dep
share/racket/collects/racket/private/compiled/base_rkt.zo
share/racket/collects/racket/private/compiled/case_rkt.dep
share/racket/collects/racket/private/compiled/case_rkt.zo
share/racket/collects/racket/private/compiled/cert_rkt.dep
share/racket/collects/racket/private/compiled/cert_rkt.zo
share/racket/collects/racket/private/compiled/class-c-new_rkt.dep
share/racket/collects/racket/private/compiled/class-c-new_rkt.zo
share/racket/collects/racket/private/compiled/class-c-old_rkt.dep
share/racket/collects/racket/private/compiled/class-c-old_rkt.zo
share/racket/collects/racket/private/compiled/class-internal_rkt.dep
share/racket/collects/racket/private/compiled/class-internal_rkt.zo
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/racket/private/compiled/class-undef_rkt.dep
share/racket/collects/racket/private/compiled/class-undef_rkt.zo
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/racket/private/compiled/class-wrapped_rkt.dep
share/racket/collects/racket/private/compiled/class-wrapped_rkt.zo
share/racket/collects/racket/private/compiled/classidmap_rkt.dep
share/racket/collects/racket/private/compiled/classidmap_rkt.zo
share/racket/collects/racket/private/compiled/cond_rkt.dep
share/racket/collects/racket/private/compiled/cond_rkt.zo
share/racket/collects/racket/private/compiled/custom-hash_rkt.dep
share/racket/collects/racket/private/compiled/custom-hash_rkt.zo
share/racket/collects/racket/private/compiled/define-et-al_rkt.dep
share/racket/collects/racket/private/compiled/define-et-al_rkt.zo
share/racket/collects/racket/private/compiled/define-struct_rkt.dep
share/racket/collects/racket/private/compiled/define-struct_rkt.zo
share/racket/collects/racket/private/compiled/define_rkt.dep
share/racket/collects/racket/private/compiled/define_rkt.zo
share/racket/collects/racket/private/compiled/dict_rkt.dep
share/racket/collects/racket/private/compiled/dict_rkt.zo
share/racket/collects/racket/private/compiled/ellipses_rkt.dep
share/racket/collects/racket/private/compiled/ellipses_rkt.zo
share/racket/collects/racket/private/compiled/for_rkt.dep
share/racket/collects/racket/private/compiled/for_rkt.zo
share/racket/collects/racket/private/compiled/generic-interfaces_rkt.dep
share/racket/collects/racket/private/compiled/generic-interfaces_rkt.zo
share/racket/collects/racket/private/compiled/generic-methods_rkt.dep
share/racket/collects/racket/private/compiled/generic-methods_rkt.zo
share/racket/collects/racket/private/compiled/generic_rkt.dep
share/racket/collects/racket/private/compiled/generic_rkt.zo
share/racket/collects/racket/private/compiled/hash_rkt.dep
share/racket/collects/racket/private/compiled/hash_rkt.zo
share/racket/collects/racket/private/compiled/increader_rkt.dep
share/racket/collects/racket/private/compiled/increader_rkt.zo
share/racket/collects/racket/private/compiled/kernstruct_rkt.dep
share/racket/collects/racket/private/compiled/kernstruct_rkt.zo
share/racket/collects/racket/private/compiled/kw-file_rkt.dep
share/racket/collects/racket/private/compiled/kw-file_rkt.zo
share/racket/collects/racket/private/compiled/kw-prop-key_rkt.dep
share/racket/collects/racket/private/compiled/kw-prop-key_rkt.zo
share/racket/collects/racket/private/compiled/kw_rkt.dep
share/racket/collects/racket/private/compiled/kw_rkt.zo
share/racket/collects/racket/private/compiled/letstx-scheme_rkt.dep
share/racket/collects/racket/private/compiled/letstx-scheme_rkt.zo
share/racket/collects/racket/private/compiled/list_rkt.dep
share/racket/collects/racket/private/compiled/list_rkt.zo
share/racket/collects/racket/private/compiled/local_rkt.dep
share/racket/collects/racket/private/compiled/local_rkt.zo
share/racket/collects/racket/private/compiled/logger_rkt.dep
share/racket/collects/racket/private/compiled/logger_rkt.zo
share/racket/collects/racket/private/compiled/map_rkt.dep
share/racket/collects/racket/private/compiled/map_rkt.zo
share/racket/collects/racket/private/compiled/member_rkt.dep
share/racket/collects/racket/private/compiled/member_rkt.zo
share/racket/collects/racket/private/compiled/misc_rkt.dep
share/racket/collects/racket/private/compiled/misc_rkt.zo
share/racket/collects/racket/private/compiled/modbeg_rkt.dep
share/racket/collects/racket/private/compiled/modbeg_rkt.zo
share/racket/collects/racket/private/compiled/more-scheme_rkt.dep
share/racket/collects/racket/private/compiled/more-scheme_rkt.zo
share/racket/collects/racket/private/compiled/name_rkt.dep
share/racket/collects/racket/private/compiled/name_rkt.zo
share/racket/collects/racket/private/compiled/namespace_rkt.dep
share/racket/collects/racket/private/compiled/namespace_rkt.zo
share/racket/collects/racket/private/compiled/norm-arity_rkt.dep
share/racket/collects/racket/private/compiled/norm-arity_rkt.zo
share/racket/collects/racket/private/compiled/norm-define_rkt.dep
share/racket/collects/racket/private/compiled/norm-define_rkt.zo
share/racket/collects/racket/private/compiled/performance-hint_rkt.dep
share/racket/collects/racket/private/compiled/performance-hint_rkt.zo
share/racket/collects/racket/private/compiled/port_rkt.dep
share/racket/collects/racket/private/compiled/port_rkt.zo
share/racket/collects/racket/private/compiled/portlines_rkt.dep
share/racket/collects/racket/private/compiled/portlines_rkt.zo
share/racket/collects/racket/private/compiled/pre-base_rkt.dep
share/racket/collects/racket/private/compiled/pre-base_rkt.zo
share/racket/collects/racket/private/compiled/procedure-alias_rkt.dep
share/racket/collects/racket/private/compiled/procedure-alias_rkt.zo
share/racket/collects/racket/private/compiled/promise_rkt.dep
share/racket/collects/racket/private/compiled/promise_rkt.zo
share/racket/collects/racket/private/compiled/qq-and-or_rkt.dep
share/racket/collects/racket/private/compiled/qq-and-or_rkt.zo
share/racket/collects/racket/private/compiled/qqstx_rkt.dep
share/racket/collects/racket/private/compiled/qqstx_rkt.zo
share/racket/collects/racket/private/compiled/reqprov_rkt.dep
share/racket/collects/racket/private/compiled/reqprov_rkt.zo
share/racket/collects/racket/private/compiled/reverse_rkt.dep
share/racket/collects/racket/private/compiled/reverse_rkt.zo
share/racket/collects/racket/private/compiled/runtime-path-table_rkt.dep
share/racket/collects/racket/private/compiled/runtime-path-table_rkt.zo
share/racket/collects/racket/private/compiled/sc_rkt.dep
share/racket/collects/racket/private/compiled/sc_rkt.zo
share/racket/collects/racket/private/compiled/sequence_rkt.dep
share/racket/collects/racket/private/compiled/sequence_rkt.zo
share/racket/collects/racket/private/compiled/serialize-structs_rkt.dep
share/racket/collects/racket/private/compiled/serialize-structs_rkt.zo
share/racket/collects/racket/private/compiled/serialize_rkt.dep
share/racket/collects/racket/private/compiled/serialize_rkt.zo
share/racket/collects/racket/private/compiled/set-types_rkt.dep
share/racket/collects/racket/private/compiled/set-types_rkt.zo
share/racket/collects/racket/private/compiled/set_rkt.dep
share/racket/collects/racket/private/compiled/set_rkt.zo
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/racket/private/compiled/shared-body_rkt.dep
share/racket/collects/racket/private/compiled/shared-body_rkt.zo
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/racket/private/compiled/small-scheme_rkt.dep
share/racket/collects/racket/private/compiled/small-scheme_rkt.zo
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/racket/private/compiled/so-search_rkt.dep
share/racket/collects/racket/private/compiled/so-search_rkt.zo
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/racket/private/compiled/sort_rkt.dep
share/racket/collects/racket/private/compiled/sort_rkt.zo
share/racket/collects/racket/private/compiled/stream-cons_rkt.dep
share/racket/collects/racket/private/compiled/stream-cons_rkt.zo
share/racket/collects/racket/private/compiled/streams_rkt.dep
share/racket/collects/racket/private/compiled/streams_rkt.zo
share/racket/collects/racket/private/compiled/string_rkt.dep
share/racket/collects/racket/private/compiled/string_rkt.zo
share/racket/collects/racket/private/compiled/struct-info_rkt.dep
share/racket/collects/racket/private/compiled/struct-info_rkt.zo
share/racket/collects/racket/private/compiled/struct_rkt.dep
share/racket/collects/racket/private/compiled/struct_rkt.zo
share/racket/collects/racket/private/compiled/stx_rkt.dep
share/racket/collects/racket/private/compiled/stx_rkt.zo
share/racket/collects/racket/private/compiled/stxcase-scheme_rkt.dep
share/racket/collects/racket/private/compiled/stxcase-scheme_rkt.zo
share/racket/collects/racket/private/compiled/stxcase_rkt.dep
share/racket/collects/racket/private/compiled/stxcase_rkt.zo
share/racket/collects/racket/private/compiled/stxloc_rkt.dep
share/racket/collects/racket/private/compiled/stxloc_rkt.zo
share/racket/collects/racket/private/compiled/stxparam_rkt.dep
share/racket/collects/racket/private/compiled/stxparam_rkt.zo
share/racket/collects/racket/private/compiled/stxparamkey_rkt.dep
share/racket/collects/racket/private/compiled/stxparamkey_rkt.zo
share/racket/collects/racket/private/compiled/submodule_rkt.dep
share/racket/collects/racket/private/compiled/submodule_rkt.zo
share/racket/collects/racket/private/compiled/this-expression-source-directory_rkt.dep
share/racket/collects/racket/private/compiled/this-expression-source-directory_rkt.zo
share/racket/collects/racket/private/compiled/top-int_rkt.dep
share/racket/collects/racket/private/compiled/top-int_rkt.zo
share/racket/collects/racket/private/compiled/unit-compiletime_rkt.dep
share/racket/collects/racket/private/compiled/unit-compiletime_rkt.zo
share/racket/collects/racket/private/compiled/unit-contract-syntax_rkt.dep
share/racket/collects/racket/private/compiled/unit-contract-syntax_rkt.zo
share/racket/collects/racket/private/compiled/unit-contract_rkt.dep
share/racket/collects/racket/private/compiled/unit-contract_rkt.zo
share/racket/collects/racket/private/compiled/unit-keywords_rkt.dep
share/racket/collects/racket/private/compiled/unit-keywords_rkt.zo
share/racket/collects/racket/private/compiled/unit-runtime_rkt.dep
share/racket/collects/racket/private/compiled/unit-runtime_rkt.zo
share/racket/collects/racket/private/compiled/unit-syntax_rkt.dep
share/racket/collects/racket/private/compiled/unit-syntax_rkt.zo
share/racket/collects/racket/private/compiled/unit-utils_rkt.dep
share/racket/collects/racket/private/compiled/unit-utils_rkt.zo
share/racket/collects/racket/private/compiled/vector-wraps_rkt.dep
share/racket/collects/racket/private/compiled/vector-wraps_rkt.zo
share/racket/collects/racket/private/compiled/with-stx_rkt.dep
share/racket/collects/racket/private/compiled/with-stx_rkt.zo
share/racket/collects/racket/private/cond.rkt
share/racket/collects/racket/private/custom-hash.rkt
share/racket/collects/racket/private/define-et-al.rkt
share/racket/collects/racket/private/define-struct.rkt
share/racket/collects/racket/private/define.rkt
share/racket/collects/racket/private/dict.rkt
share/racket/collects/racket/private/ellipses.rkt
share/racket/collects/racket/private/for.rkt
share/racket/collects/racket/private/generic-interfaces.rkt
share/racket/collects/racket/private/generic-methods.rkt
share/racket/collects/racket/private/generic.rkt
share/racket/collects/racket/private/hash.rkt
share/racket/collects/racket/private/increader.rkt
share/racket/collects/racket/private/kernstruct.rkt
share/racket/collects/racket/private/kw-file.rkt
share/racket/collects/racket/private/kw-prop-key.rkt
share/racket/collects/racket/private/kw.rkt
share/racket/collects/racket/private/letstx-scheme.rkt
share/racket/collects/racket/private/list.rkt
share/racket/collects/racket/private/local.rkt
share/racket/collects/racket/private/logger.rkt
share/racket/collects/racket/private/map.rkt
share/racket/collects/racket/private/member.rkt
share/racket/collects/racket/private/misc.rkt
share/racket/collects/racket/private/modbeg.rkt
share/racket/collects/racket/private/more-scheme.rkt
share/racket/collects/racket/private/name.rkt
share/racket/collects/racket/private/namespace.rkt
share/racket/collects/racket/private/norm-arity.rkt
share/racket/collects/racket/private/norm-define.rkt
share/racket/collects/racket/private/performance-hint.rkt
share/racket/collects/racket/private/port.rkt
share/racket/collects/racket/private/portlines.rkt
share/racket/collects/racket/private/pre-base.rkt
share/racket/collects/racket/private/procedure-alias.rkt
share/racket/collects/racket/private/promise.rkt
share/racket/collects/racket/private/qq-and-or.rkt
share/racket/collects/racket/private/qqstx.rkt
share/racket/collects/racket/private/reqprov.rkt
share/racket/collects/racket/private/reverse.rkt
share/racket/collects/racket/private/runtime-path-table.rkt
share/racket/collects/racket/private/sc.rkt
share/racket/collects/racket/private/sequence.rkt
share/racket/collects/racket/private/serialize-structs.rkt
share/racket/collects/racket/private/serialize.rkt
share/racket/collects/racket/private/set-types.rkt
share/racket/collects/racket/private/set.rkt
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/racket/private/shared-body.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/racket/private/small-scheme.rkt
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/racket/private/so-search.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/racket/private/sort.rkt
share/racket/collects/racket/private/stream-cons.rkt
share/racket/collects/racket/private/streams.rkt
share/racket/collects/racket/private/string.rkt
share/racket/collects/racket/private/struct-info.rkt
share/racket/collects/racket/private/struct.rkt
share/racket/collects/racket/private/stx.rkt
share/racket/collects/racket/private/stxcase-scheme.rkt
share/racket/collects/racket/private/stxcase.rkt
share/racket/collects/racket/private/stxloc.rkt
share/racket/collects/racket/private/stxparam.rkt
share/racket/collects/racket/private/stxparamkey.rkt
share/racket/collects/racket/private/submodule.rkt
share/racket/collects/racket/private/this-expression-source-directory.rkt
share/racket/collects/racket/private/top-int.rkt
share/racket/collects/racket/private/unit-compiletime.rkt
share/racket/collects/racket/private/unit-contract-syntax.rkt
share/racket/collects/racket/private/unit-contract.rkt
share/racket/collects/racket/private/unit-keywords.rkt
share/racket/collects/racket/private/unit-runtime.rkt
share/racket/collects/racket/private/unit-syntax.rkt
share/racket/collects/racket/private/unit-utils.rkt
share/racket/collects/racket/private/vector-wraps.rkt
share/racket/collects/racket/private/with-stx.rkt
share/racket/collects/racket/promise.rkt
share/racket/collects/racket/provide-syntax.rkt
share/racket/collects/racket/provide-transform.rkt
share/racket/collects/racket/provide.rkt
share/racket/collects/racket/racket.1
share/racket/collects/racket/require-syntax.rkt
share/racket/collects/racket/require-transform.rkt
share/racket/collects/racket/require.rkt
share/racket/collects/racket/rerequire.rkt
share/racket/collects/racket/runtime-config.rkt
share/racket/collects/racket/runtime-path.rkt
share/racket/collects/racket/sequence.rkt
share/racket/collects/racket/serialize.rkt
share/racket/collects/racket/set.rkt
share/racket/collects/racket/shared.rkt
share/racket/collects/racket/signature/compiled/lang_rkt.dep
share/racket/collects/racket/signature/compiled/lang_rkt.zo
share/racket/collects/racket/signature/lang.rkt
share/racket/collects/racket/signature/lang/compiled/reader_rkt.dep
share/racket/collects/racket/signature/lang/compiled/reader_rkt.zo
share/racket/collects/racket/signature/lang/reader.rkt
share/racket/collects/racket/splicing.rkt
share/racket/collects/racket/stream.rkt
share/racket/collects/racket/string.rkt
share/racket/collects/racket/struct-info.rkt
share/racket/collects/racket/stxparam-exptime.rkt
share/racket/collects/racket/stxparam.rkt
share/racket/collects/racket/surrogate.rkt
share/racket/collects/racket/syntax.rkt
share/racket/collects/racket/system.rkt
share/racket/collects/racket/tcp.rkt
share/racket/collects/racket/trace.rkt
share/racket/collects/racket/trait.rkt
share/racket/collects/racket/udp.rkt
share/racket/collects/racket/undefined.rkt
share/racket/collects/racket/unit-exptime.rkt
share/racket/collects/racket/unit.rkt
share/racket/collects/racket/unit/compiled/lang_rkt.dep
share/racket/collects/racket/unit/compiled/lang_rkt.zo
share/racket/collects/racket/unit/lang.rkt
share/racket/collects/racket/unit/lang/compiled/reader_rkt.dep
share/racket/collects/racket/unit/lang/compiled/reader_rkt.zo
share/racket/collects/racket/unit/lang/reader.rkt
share/racket/collects/racket/unsafe/compiled/ops_rkt.dep
share/racket/collects/racket/unsafe/compiled/ops_rkt.zo
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/racket/unsafe/compiled/undefined_rkt.dep
share/racket/collects/racket/unsafe/compiled/undefined_rkt.zo
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/racket/unsafe/ops.rkt
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/racket/unsafe/undefined.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/racket/vector.rkt
share/racket/collects/raco/all-tools.rkt
share/racket/collects/raco/command-name.rkt
share/racket/collects/raco/compiled/all-tools_rkt.dep
share/racket/collects/raco/compiled/all-tools_rkt.zo
share/racket/collects/raco/compiled/command-name_rkt.dep
share/racket/collects/raco/compiled/command-name_rkt.zo
share/racket/collects/raco/compiled/info_rkt.dep
share/racket/collects/raco/compiled/info_rkt.zo
share/racket/collects/raco/compiled/raco_rkt.dep
share/racket/collects/raco/compiled/raco_rkt.zo
share/racket/collects/raco/doc.ico
share/racket/collects/raco/info.rkt
share/racket/collects/raco/main.extreg
share/racket/collects/raco/main.lch
share/racket/collects/raco/main.rkt
share/racket/collects/raco/raco.1
share/racket/collects/raco/raco.rkt
share/racket/collects/reader/lang/compiled/reader_rkt.dep
share/racket/collects/reader/lang/compiled/reader_rkt.zo
share/racket/collects/reader/lang/reader.rkt
share/racket/collects/realm/README.txt
share/racket/collects/s-exp/lang/compiled/reader_rkt.dep
share/racket/collects/s-exp/lang/compiled/reader_rkt.zo
share/racket/collects/s-exp/lang/reader.rkt
share/racket/collects/setup/collection-name.rkt
share/racket/collects/setup/collects.rkt
share/racket/collects/setup/commands/compiled/link_rkt.dep
share/racket/collects/setup/commands/compiled/link_rkt.zo
share/racket/collects/setup/commands/link.rkt
share/racket/collects/setup/compiled/collection-name_rkt.dep
share/racket/collects/setup/compiled/collection-name_rkt.zo
share/racket/collects/setup/compiled/collects_rkt.dep
share/racket/collects/setup/compiled/collects_rkt.zo
share/racket/collects/setup/compiled/dirs_rkt.dep
share/racket/collects/setup/compiled/dirs_rkt.zo
share/racket/collects/setup/compiled/doc-db_rkt.dep
share/racket/collects/setup/compiled/doc-db_rkt.zo
share/racket/collects/setup/compiled/getinfo_rkt.dep
share/racket/collects/setup/compiled/getinfo_rkt.zo
share/racket/collects/setup/compiled/info_rkt.dep
share/racket/collects/setup/compiled/info_rkt.zo
share/racket/collects/setup/compiled/infotab_rkt.dep
share/racket/collects/setup/compiled/infotab_rkt.zo
share/racket/collects/setup/compiled/link_rkt.dep
share/racket/collects/setup/compiled/link_rkt.zo
share/racket/collects/setup/compiled/main-collects_rkt.dep
share/racket/collects/setup/compiled/main-collects_rkt.zo
share/racket/collects/setup/compiled/main-doc_rkt.dep
share/racket/collects/setup/compiled/main-doc_rkt.zo
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/setup/compiled/matching-platform_rkt.dep
share/racket/collects/setup/compiled/matching-platform_rkt.zo
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/setup/compiled/option_rkt.dep
share/racket/collects/setup/compiled/option_rkt.zo
share/racket/collects/setup/compiled/pack_rkt.dep
share/racket/collects/setup/compiled/pack_rkt.zo
share/racket/collects/setup/compiled/parallel-build_rkt.dep
share/racket/collects/setup/compiled/parallel-build_rkt.zo
share/racket/collects/setup/compiled/parallel-do_rkt.dep
share/racket/collects/setup/compiled/parallel-do_rkt.zo
share/racket/collects/setup/compiled/path-relativize_rkt.dep
share/racket/collects/setup/compiled/path-relativize_rkt.zo
share/racket/collects/setup/compiled/path-to-relative_rkt.dep
share/racket/collects/setup/compiled/path-to-relative_rkt.zo
share/racket/collects/setup/compiled/plt-single-installer_rkt.dep
share/racket/collects/setup/compiled/plt-single-installer_rkt.zo
share/racket/collects/setup/compiled/setup-cmdline_rkt.dep
share/racket/collects/setup/compiled/setup-cmdline_rkt.zo
share/racket/collects/setup/compiled/setup-core_rkt.dep
share/racket/collects/setup/compiled/setup-core_rkt.zo
share/racket/collects/setup/compiled/setup-go_rkt.dep
share/racket/collects/setup/compiled/setup-go_rkt.zo
share/racket/collects/setup/compiled/setup_rkt.dep
share/racket/collects/setup/compiled/setup_rkt.zo
share/racket/collects/setup/compiled/unixstyle-install_rkt.dep
share/racket/collects/setup/compiled/unixstyle-install_rkt.zo
share/racket/collects/setup/compiled/unpack_rkt.dep
share/racket/collects/setup/compiled/unpack_rkt.zo
share/racket/collects/setup/compiled/variant_rkt.dep
share/racket/collects/setup/compiled/variant_rkt.zo
share/racket/collects/setup/compiled/winstrip_rkt.dep
share/racket/collects/setup/compiled/winstrip_rkt.zo
share/racket/collects/setup/compiled/winvers-change_rkt.dep
share/racket/collects/setup/compiled/winvers-change_rkt.zo
share/racket/collects/setup/compiled/winvers_rkt.dep
share/racket/collects/setup/compiled/winvers_rkt.zo
share/racket/collects/setup/dirs.rkt
share/racket/collects/setup/doc-db.rkt
share/racket/collects/setup/getinfo.rkt
share/racket/collects/setup/info.rkt
share/racket/collects/setup/infotab.rkt
share/racket/collects/setup/infotab/lang/compiled/reader_rkt.dep
share/racket/collects/setup/infotab/lang/compiled/reader_rkt.zo
share/racket/collects/setup/infotab/lang/reader.rkt
share/racket/collects/setup/link.rkt
share/racket/collects/setup/main-collects.rkt
share/racket/collects/setup/main-doc.rkt
share/racket/collects/setup/main.lch
share/racket/collects/setup/main.rkt
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/setup/matching-platform.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/setup/option.rkt
share/racket/collects/setup/pack.rkt
share/racket/collects/setup/parallel-build.rkt
share/racket/collects/setup/parallel-do.rkt
share/racket/collects/setup/path-relativize.rkt
share/racket/collects/setup/path-to-relative.rkt
share/racket/collects/setup/plt-single-installer.rkt
share/racket/collects/setup/private/cc-struct.rkt
share/racket/collects/setup/private/command-name.rkt
share/racket/collects/setup/private/compiled/cc-struct_rkt.dep
share/racket/collects/setup/private/compiled/cc-struct_rkt.zo
share/racket/collects/setup/private/compiled/command-name_rkt.dep
share/racket/collects/setup/private/compiled/command-name_rkt.zo
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/setup/private/compiled/dylib_rkt.dep
share/racket/collects/setup/private/compiled/dylib_rkt.zo
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?)
2015-08-05 23:14:29 +02:00
share/racket/collects/setup/private/compiled/elf_rkt.dep
share/racket/collects/setup/private/compiled/elf_rkt.zo
share/racket/collects/setup/private/compiled/format-error_rkt.dep
share/racket/collects/setup/private/compiled/format-error_rkt.zo
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/setup/private/compiled/lib-roots_rkt.dep
share/racket/collects/setup/private/compiled/lib-roots_rkt.zo
share/racket/collects/setup/private/compiled/omitted-paths_rkt.dep
share/racket/collects/setup/private/compiled/omitted-paths_rkt.zo
share/racket/collects/setup/private/compiled/pkg-deps_rkt.dep
share/racket/collects/setup/private/compiled/pkg-deps_rkt.zo
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/setup/private/dylib.rkt
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?)
2015-08-05 23:14:29 +02:00
share/racket/collects/setup/private/elf.rkt
share/racket/collects/setup/private/format-error.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/setup/private/lib-roots.rkt
share/racket/collects/setup/private/omitted-paths.rkt
share/racket/collects/setup/private/pkg-deps.rkt
share/racket/collects/setup/setup-cmdline.rkt
share/racket/collects/setup/setup-core.rkt
share/racket/collects/setup/setup-go.rkt
share/racket/collects/setup/setup.rkt
share/racket/collects/setup/unixstyle-install.rkt
share/racket/collects/setup/unpack.rkt
share/racket/collects/setup/variant.rkt
share/racket/collects/setup/winstrip.rkt
share/racket/collects/setup/winvers-change.rkt
share/racket/collects/setup/winvers.rkt
share/racket/collects/syntax/boundmap.rkt
share/racket/collects/syntax/compiled/boundmap_rkt.dep
share/racket/collects/syntax/compiled/boundmap_rkt.zo
share/racket/collects/syntax/compiled/context_rkt.dep
share/racket/collects/syntax/compiled/context_rkt.zo
share/racket/collects/syntax/compiled/datum_rkt.dep
share/racket/collects/syntax/compiled/datum_rkt.zo
share/racket/collects/syntax/compiled/define_rkt.dep
share/racket/collects/syntax/compiled/define_rkt.zo
share/racket/collects/syntax/compiled/docprovide_rkt.dep
share/racket/collects/syntax/compiled/docprovide_rkt.zo
share/racket/collects/syntax/compiled/flatten-begin_rkt.dep
share/racket/collects/syntax/compiled/flatten-begin_rkt.zo
share/racket/collects/syntax/compiled/for-body_rkt.dep
share/racket/collects/syntax/compiled/for-body_rkt.zo
share/racket/collects/syntax/compiled/free-vars_rkt.dep
share/racket/collects/syntax/compiled/free-vars_rkt.zo
share/racket/collects/syntax/compiled/id-table_rkt.dep
share/racket/collects/syntax/compiled/id-table_rkt.zo
share/racket/collects/syntax/compiled/kerncase_rkt.dep
share/racket/collects/syntax/compiled/kerncase_rkt.zo
share/racket/collects/syntax/compiled/keyword_rkt.dep
share/racket/collects/syntax/compiled/keyword_rkt.zo
share/racket/collects/syntax/compiled/location_rkt.dep
share/racket/collects/syntax/compiled/location_rkt.zo
share/racket/collects/syntax/compiled/modcode_rkt.dep
share/racket/collects/syntax/compiled/modcode_rkt.zo
share/racket/collects/syntax/compiled/modcollapse_rkt.dep
share/racket/collects/syntax/compiled/modcollapse_rkt.zo
share/racket/collects/syntax/compiled/moddep_rkt.dep
share/racket/collects/syntax/compiled/moddep_rkt.zo
share/racket/collects/syntax/compiled/modread_rkt.dep
share/racket/collects/syntax/compiled/modread_rkt.zo
share/racket/collects/syntax/compiled/modresolve_rkt.dep
share/racket/collects/syntax/compiled/modresolve_rkt.zo
share/racket/collects/syntax/compiled/module-reader_rkt.dep
share/racket/collects/syntax/compiled/module-reader_rkt.zo
share/racket/collects/syntax/compiled/name_rkt.dep
share/racket/collects/syntax/compiled/name_rkt.zo
share/racket/collects/syntax/compiled/parse_rkt.dep
share/racket/collects/syntax/compiled/parse_rkt.zo
share/racket/collects/syntax/compiled/path-spec_rkt.dep
share/racket/collects/syntax/compiled/path-spec_rkt.zo
share/racket/collects/syntax/compiled/primitives_rkt.dep
share/racket/collects/syntax/compiled/primitives_rkt.zo
share/racket/collects/syntax/compiled/quote_rkt.dep
share/racket/collects/syntax/compiled/quote_rkt.zo
share/racket/collects/syntax/compiled/readerr_rkt.dep
share/racket/collects/syntax/compiled/readerr_rkt.zo
share/racket/collects/syntax/compiled/srcloc_rkt.dep
share/racket/collects/syntax/compiled/srcloc_rkt.zo
share/racket/collects/syntax/compiled/strip-context_rkt.dep
share/racket/collects/syntax/compiled/strip-context_rkt.zo
share/racket/collects/syntax/compiled/struct_rkt.dep
share/racket/collects/syntax/compiled/struct_rkt.zo
share/racket/collects/syntax/compiled/stx_rkt.dep
share/racket/collects/syntax/compiled/stx_rkt.zo
share/racket/collects/syntax/compiled/template_rkt.dep
share/racket/collects/syntax/compiled/template_rkt.zo
share/racket/collects/syntax/compiled/to-string_rkt.dep
share/racket/collects/syntax/compiled/to-string_rkt.zo
share/racket/collects/syntax/compiled/toplevel_rkt.dep
share/racket/collects/syntax/compiled/toplevel_rkt.zo
share/racket/collects/syntax/compiled/trusted-xforms_rkt.dep
share/racket/collects/syntax/compiled/trusted-xforms_rkt.zo
share/racket/collects/syntax/compiled/wrap-modbeg_rkt.dep
share/racket/collects/syntax/compiled/wrap-modbeg_rkt.zo
share/racket/collects/syntax/context.rkt
share/racket/collects/syntax/datum.rkt
share/racket/collects/syntax/define.rkt
share/racket/collects/syntax/doc.txt
share/racket/collects/syntax/docprovide.rkt
share/racket/collects/syntax/flatten-begin.rkt
share/racket/collects/syntax/for-body.rkt
share/racket/collects/syntax/free-vars.rkt
share/racket/collects/syntax/id-table.rkt
share/racket/collects/syntax/kerncase.rkt
share/racket/collects/syntax/keyword.rkt
share/racket/collects/syntax/location.rkt
share/racket/collects/syntax/modcode.rkt
share/racket/collects/syntax/modcollapse.rkt
share/racket/collects/syntax/moddep.rkt
share/racket/collects/syntax/modread.rkt
share/racket/collects/syntax/modresolve.rkt
share/racket/collects/syntax/module-reader.rkt
share/racket/collects/syntax/name.rkt
share/racket/collects/syntax/parse.rkt
share/racket/collects/syntax/parse/compiled/debug_rkt.dep
share/racket/collects/syntax/parse/compiled/debug_rkt.zo
share/racket/collects/syntax/parse/compiled/define_rkt.dep
share/racket/collects/syntax/parse/compiled/define_rkt.zo
share/racket/collects/syntax/parse/compiled/pre_rkt.dep
share/racket/collects/syntax/parse/compiled/pre_rkt.zo
share/racket/collects/syntax/parse/debug.rkt
share/racket/collects/syntax/parse/define.rkt
share/racket/collects/syntax/parse/experimental/compiled/contract_rkt.dep
share/racket/collects/syntax/parse/experimental/compiled/contract_rkt.zo
share/racket/collects/syntax/parse/experimental/compiled/eh_rkt.dep
share/racket/collects/syntax/parse/experimental/compiled/eh_rkt.zo
share/racket/collects/syntax/parse/experimental/compiled/provide_rkt.dep
share/racket/collects/syntax/parse/experimental/compiled/provide_rkt.zo
share/racket/collects/syntax/parse/experimental/compiled/reflect_rkt.dep
share/racket/collects/syntax/parse/experimental/compiled/reflect_rkt.zo
share/racket/collects/syntax/parse/experimental/compiled/specialize_rkt.dep
share/racket/collects/syntax/parse/experimental/compiled/specialize_rkt.zo
share/racket/collects/syntax/parse/experimental/compiled/splicing_rkt.dep
share/racket/collects/syntax/parse/experimental/compiled/splicing_rkt.zo
share/racket/collects/syntax/parse/experimental/compiled/template_rkt.dep
share/racket/collects/syntax/parse/experimental/compiled/template_rkt.zo
share/racket/collects/syntax/parse/experimental/contract.rkt
share/racket/collects/syntax/parse/experimental/eh.rkt
share/racket/collects/syntax/parse/experimental/private/compiled/substitute_rkt.dep
share/racket/collects/syntax/parse/experimental/private/compiled/substitute_rkt.zo
share/racket/collects/syntax/parse/experimental/private/substitute.rkt
share/racket/collects/syntax/parse/experimental/provide.rkt
share/racket/collects/syntax/parse/experimental/reflect.rkt
share/racket/collects/syntax/parse/experimental/specialize.rkt
share/racket/collects/syntax/parse/experimental/splicing.rkt
share/racket/collects/syntax/parse/experimental/template.rkt
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?)
2015-08-05 23:14:29 +02:00
share/racket/collects/syntax/parse/lib/compiled/function-header_rkt.dep
share/racket/collects/syntax/parse/lib/compiled/function-header_rkt.zo
share/racket/collects/syntax/parse/lib/function-header.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/syntax/parse/pre.rkt
share/racket/collects/syntax/parse/private/3d-stx.rkt
share/racket/collects/syntax/parse/private/compiled/3d-stx_rkt.dep
share/racket/collects/syntax/parse/private/compiled/3d-stx_rkt.zo
share/racket/collects/syntax/parse/private/compiled/keywords_rkt.dep
share/racket/collects/syntax/parse/private/compiled/keywords_rkt.zo
share/racket/collects/syntax/parse/private/compiled/kws_rkt.dep
share/racket/collects/syntax/parse/private/compiled/kws_rkt.zo
share/racket/collects/syntax/parse/private/compiled/lib_rkt.dep
share/racket/collects/syntax/parse/private/compiled/lib_rkt.zo
share/racket/collects/syntax/parse/private/compiled/litconv_rkt.dep
share/racket/collects/syntax/parse/private/compiled/litconv_rkt.zo
share/racket/collects/syntax/parse/private/compiled/minimatch_rkt.dep
share/racket/collects/syntax/parse/private/compiled/minimatch_rkt.zo
share/racket/collects/syntax/parse/private/compiled/opt_rkt.dep
share/racket/collects/syntax/parse/private/compiled/opt_rkt.zo
share/racket/collects/syntax/parse/private/compiled/parse-aux_rkt.dep
share/racket/collects/syntax/parse/private/compiled/parse-aux_rkt.zo
share/racket/collects/syntax/parse/private/compiled/parse_rkt.dep
share/racket/collects/syntax/parse/private/compiled/parse_rkt.zo
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/syntax/parse/private/compiled/pattern-expander-prop_rkt.dep
share/racket/collects/syntax/parse/private/compiled/pattern-expander-prop_rkt.zo
share/racket/collects/syntax/parse/private/compiled/pattern-expander_rkt.dep
share/racket/collects/syntax/parse/private/compiled/pattern-expander_rkt.zo
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/syntax/parse/private/compiled/rep-attrs_rkt.dep
share/racket/collects/syntax/parse/private/compiled/rep-attrs_rkt.zo
share/racket/collects/syntax/parse/private/compiled/rep-data_rkt.dep
share/racket/collects/syntax/parse/private/compiled/rep-data_rkt.zo
share/racket/collects/syntax/parse/private/compiled/rep-patterns_rkt.dep
share/racket/collects/syntax/parse/private/compiled/rep-patterns_rkt.zo
share/racket/collects/syntax/parse/private/compiled/rep_rkt.dep
share/racket/collects/syntax/parse/private/compiled/rep_rkt.zo
share/racket/collects/syntax/parse/private/compiled/residual-ct_rkt.dep
share/racket/collects/syntax/parse/private/compiled/residual-ct_rkt.zo
share/racket/collects/syntax/parse/private/compiled/residual_rkt.dep
share/racket/collects/syntax/parse/private/compiled/residual_rkt.zo
share/racket/collects/syntax/parse/private/compiled/runtime-progress_rkt.dep
share/racket/collects/syntax/parse/private/compiled/runtime-progress_rkt.zo
share/racket/collects/syntax/parse/private/compiled/runtime-reflect_rkt.dep
share/racket/collects/syntax/parse/private/compiled/runtime-reflect_rkt.zo
share/racket/collects/syntax/parse/private/compiled/runtime-report_rkt.dep
share/racket/collects/syntax/parse/private/compiled/runtime-report_rkt.zo
share/racket/collects/syntax/parse/private/compiled/runtime_rkt.dep
share/racket/collects/syntax/parse/private/compiled/runtime_rkt.zo
share/racket/collects/syntax/parse/private/compiled/sc_rkt.dep
share/racket/collects/syntax/parse/private/compiled/sc_rkt.zo
share/racket/collects/syntax/parse/private/compiled/txlift_rkt.dep
share/racket/collects/syntax/parse/private/compiled/txlift_rkt.zo
share/racket/collects/syntax/parse/private/keywords.rkt
share/racket/collects/syntax/parse/private/kws.rkt
share/racket/collects/syntax/parse/private/lib.rkt
share/racket/collects/syntax/parse/private/litconv.rkt
share/racket/collects/syntax/parse/private/minimatch.rkt
share/racket/collects/syntax/parse/private/opt.rkt
share/racket/collects/syntax/parse/private/parse-aux.rkt
share/racket/collects/syntax/parse/private/parse.rkt
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.
2015-03-04 16:02:36 +01:00
share/racket/collects/syntax/parse/private/pattern-expander-prop.rkt
share/racket/collects/syntax/parse/private/pattern-expander.rkt
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.
2014-06-15 11:35:28 +02:00
share/racket/collects/syntax/parse/private/rep-attrs.rkt
share/racket/collects/syntax/parse/private/rep-data.rkt
share/racket/collects/syntax/parse/private/rep-patterns.rkt
share/racket/collects/syntax/parse/private/rep.rkt
share/racket/collects/syntax/parse/private/residual-ct.rkt
share/racket/collects/syntax/parse/private/residual.rkt
share/racket/collects/syntax/parse/private/runtime-progress.rkt
share/racket/collects/syntax/parse/private/runtime-reflect.rkt
share/racket/collects/syntax/parse/private/runtime-report.rkt
share/racket/collects/syntax/parse/private/runtime.rkt
share/racket/collects/syntax/parse/private/sc.rkt
share/racket/collects/syntax/parse/private/txlift.rkt
share/racket/collects/syntax/parse/todo.txt
share/racket/collects/syntax/path-spec.rkt
share/racket/collects/syntax/primitives.rkt
share/racket/collects/syntax/private/boundmap.rkt
share/racket/collects/syntax/private/compiled/boundmap_rkt.dep
share/racket/collects/syntax/private/compiled/boundmap_rkt.zo
share/racket/collects/syntax/private/compiled/doctable_rkt.dep
share/racket/collects/syntax/private/compiled/doctable_rkt.zo
share/racket/collects/syntax/private/compiled/id-table_rkt.dep
share/racket/collects/syntax/private/compiled/id-table_rkt.zo
share/racket/collects/syntax/private/compiled/keyword_rkt.dep
share/racket/collects/syntax/private/compiled/keyword_rkt.zo
share/racket/collects/syntax/private/compiled/modcollapse-noctc_rkt.dep
share/racket/collects/syntax/private/compiled/modcollapse-noctc_rkt.zo
share/racket/collects/syntax/private/compiled/modhelp_rkt.dep
share/racket/collects/syntax/private/compiled/modhelp_rkt.zo
share/racket/collects/syntax/private/compiled/template-runtime_rkt.dep
share/racket/collects/syntax/private/compiled/template-runtime_rkt.zo
share/racket/collects/syntax/private/doctable.rkt
share/racket/collects/syntax/private/id-table.rkt
share/racket/collects/syntax/private/keyword.rkt
share/racket/collects/syntax/private/modcollapse-noctc.rkt
share/racket/collects/syntax/private/modhelp.rkt
share/racket/collects/syntax/private/template-runtime.rkt
share/racket/collects/syntax/private/util/compiled/expand_rkt.dep
share/racket/collects/syntax/private/util/compiled/expand_rkt.zo
share/racket/collects/syntax/private/util/expand.rkt
share/racket/collects/syntax/quote.rkt
share/racket/collects/syntax/readerr.rkt
share/racket/collects/syntax/srcloc.rkt
share/racket/collects/syntax/strip-context.rkt
share/racket/collects/syntax/struct.rkt
share/racket/collects/syntax/stx.rkt
share/racket/collects/syntax/template.rkt
share/racket/collects/syntax/to-string.rkt
share/racket/collects/syntax/toplevel.rkt
share/racket/collects/syntax/trusted-xforms.rkt
share/racket/collects/syntax/unsafe/compiled/for-transform_rkt.dep
share/racket/collects/syntax/unsafe/compiled/for-transform_rkt.zo
share/racket/collects/syntax/unsafe/for-transform.rkt
share/racket/collects/syntax/wrap-modbeg.rkt
share/racket/collects/unstable/compiled/custom-write_rkt.dep
share/racket/collects/unstable/compiled/custom-write_rkt.zo
share/racket/collects/unstable/compiled/error_rkt.dep
share/racket/collects/unstable/compiled/error_rkt.zo
share/racket/collects/unstable/compiled/markparam_rkt.dep
share/racket/collects/unstable/compiled/markparam_rkt.zo
share/racket/collects/unstable/compiled/sequence_rkt.dep
share/racket/collects/unstable/compiled/sequence_rkt.zo
share/racket/collects/unstable/compiled/socket_rkt.dep
share/racket/collects/unstable/compiled/socket_rkt.zo
share/racket/collects/unstable/compiled/struct_rkt.dep
share/racket/collects/unstable/compiled/struct_rkt.zo
share/racket/collects/unstable/compiled/syntax_rkt.dep
share/racket/collects/unstable/compiled/syntax_rkt.zo
share/racket/collects/unstable/compiled/wrapc_rkt.dep
share/racket/collects/unstable/compiled/wrapc_rkt.zo
share/racket/collects/unstable/custom-write.rkt
share/racket/collects/unstable/error.rkt
share/racket/collects/unstable/markparam.rkt
share/racket/collects/unstable/sequence.rkt
share/racket/collects/unstable/socket.rkt
share/racket/collects/unstable/struct.rkt
share/racket/collects/unstable/syntax.rkt
share/racket/collects/unstable/wrapc.rkt
share/racket/collects/version/check.rkt
share/racket/collects/version/compiled/check_rkt.dep
share/racket/collects/version/compiled/check_rkt.zo
share/racket/collects/version/compiled/patchlevel_rkt.dep
share/racket/collects/version/compiled/patchlevel_rkt.zo
share/racket/collects/version/compiled/utils_rkt.dep
share/racket/collects/version/compiled/utils_rkt.zo
share/racket/collects/version/patchlevel.rkt
share/racket/collects/version/utils.rkt
share/racket/collects/xml/compiled/main_rkt.dep
share/racket/collects/xml/compiled/main_rkt.zo
share/racket/collects/xml/compiled/path_rkt.dep
share/racket/collects/xml/compiled/path_rkt.zo
share/racket/collects/xml/compiled/plist_rkt.dep
share/racket/collects/xml/compiled/plist_rkt.zo
share/racket/collects/xml/compiled/xexpr_rkt.dep
share/racket/collects/xml/compiled/xexpr_rkt.zo
share/racket/collects/xml/compiled/xml_rkt.dep
share/racket/collects/xml/compiled/xml_rkt.zo
share/racket/collects/xml/main.rkt
share/racket/collects/xml/path.rkt
share/racket/collects/xml/plist.rkt
share/racket/collects/xml/private/compiled/core_rkt.dep
share/racket/collects/xml/private/compiled/core_rkt.zo
share/racket/collects/xml/private/compiled/reader_rkt.dep
share/racket/collects/xml/private/compiled/reader_rkt.zo
share/racket/collects/xml/private/compiled/space_rkt.dep
share/racket/collects/xml/private/compiled/space_rkt.zo
share/racket/collects/xml/private/compiled/structures_rkt.dep
share/racket/collects/xml/private/compiled/structures_rkt.zo
share/racket/collects/xml/private/compiled/syntax_rkt.dep
share/racket/collects/xml/private/compiled/syntax_rkt.zo
share/racket/collects/xml/private/compiled/writer_rkt.dep
share/racket/collects/xml/private/compiled/writer_rkt.zo
share/racket/collects/xml/private/compiled/xexpr-core_rkt.dep
share/racket/collects/xml/private/compiled/xexpr-core_rkt.zo
share/racket/collects/xml/private/compiled/xexpr_rkt.dep
share/racket/collects/xml/private/compiled/xexpr_rkt.zo
share/racket/collects/xml/private/core.rkt
share/racket/collects/xml/private/reader.rkt
share/racket/collects/xml/private/space.rkt
share/racket/collects/xml/private/structures.rkt
share/racket/collects/xml/private/syntax.rkt
share/racket/collects/xml/private/writer.rkt
share/racket/collects/xml/private/xexpr-core.rkt
share/racket/collects/xml/private/xexpr.rkt
share/racket/collects/xml/xexpr.rkt
share/racket/collects/xml/xml.rkt
share/racket/links.rktd
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?)
2015-08-05 23:14:29 +02:00
share/racket/pkgs/.LOCKpkgs.rktd
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.
2014-06-15 11:35:28 +02:00
share/racket/pkgs/pkgs.rktd
share/racket/pkgs/racket-lib/LICENSE.txt
share/racket/pkgs/racket-lib/info.rkt
Reference in a new issue Copy permalink