includes a new pass, letrec_check, two new primitives, and
changes to packages that grabbed the letrec undefined value
original commit: 72c958df628690ebc52a626d35cd4edcab0c7089
It seems more ideal that `pkg-authors` would be specific enough
responsibility, but our existing allocations of responsibility are
more fine-grained, and we keep them for now.
original commit: 19f8f30f63ece380105f69796c046c7a00aa4f97
The main changes are the addition of a new way to specify projections,
using the #:val-first-projection keyword argument; the main goal of the
new API is that more information can be supplied to the projection on
the server side of the contract boundary. In addition, the arrow contracts
will now, internally and in some cases (see define-module-boundary-contract)
return functions that accept one additional argument than the original
function did and then insert the name of the negative party into call sites.
The rough idea is that if you have a program like this one:
#lang racket/base
(define (f x) (+ x 1))
(provide (contract-out [f (-> integer? integer?)]))
then the contract system produces something much closer to this:
#lang racket/base
(define (f x) (+ x 1))
(provide (rename-out [external-f f]))
(define (external-f neg-party x)
(check-integer neg-party x)
(define ans (f x))
(check-integer neg-party ans)
ans)
(define local-blame-information ...)
(define (check-integer neg-party v)
(unless (integer? v)
(raise-blame-error local-blame-information
#:missing-party neg-party
...)))
where 'raise-blame-error' can now cope with blame objects that don't
have negative part information in them (when the #:missing-party
argument is supplied, essentially just reassembling the original blame
record at that point)
Then, on the client side, if we had
(f x)
it gets transformed into
(f '<<my-modules-name>> x)
and if we had
(let ([g f])
...)
you get a slow path:
(let ([g (lambda (x) (f '<<my-modules-name>> x))])
...)
(where we don't create a wrapper lambda, of course, we actually create
a procedure chaperone)
The performance improvements seem pretty good (see below for the
precise programs that I ran and the numbers I got):
first order contract microbenchmark: 6x speedup
higher-order contract microbenchmark: 1.5x speedup
first-order TR contract interop micro benchmark: 6x speedup
This also improves the memory use for DrRacket by about 3% (from about
236.8 mb to 231.3 mb), presumably because more of the data structures
created by the contract system can be created only once, on the server
side.
Be aware, however, that not all combinators are using the new
projections and the code that translates between the two APIs
is slow.
Also there are a bunch of other changes that got made while I was
doing this. Most notably, the change above were not designed for the
performance improvements to arrow contracts, but to make it possible
to implement class/c contracts with a (hopefully) negligible space
overhead. That work is not yet finished, but this commit includes some
changes to the class system to prepare the way for those changes.
Unfortuantely, these changes slow down 'send' on microbenchmarks by
about 24%. The change comes from the addition of an extra 'if' (and
predicate test and possibly the extra let expresison) that's inserted
into the expansion. I'm not happy about that (I was shooting for 10%)
but I'm not sure that we can do much about it (except perhaps double
check my measurements, see below).
Other misc changes:
- improve arity mismatch error messages by including the arity of the
given procedure (closes PR 14220)
- Adjust case-> so it generates less code. This seems to reduce the
size of the math library .zo files by about 3% (from 10440k to
10156k for me)
- speeds up the contract tests a bit
- move recontract out into racket/contract (also, document it)
- added define-module-boundary-contract
- streamline TR's any-wrap/c and adjust it to use
#:val-first-projection instead of #:projection
- adjust a bunch of contracts to print more nicely
- and, of course, Rackety
--------------------------------
The precise programs that I tried and their timings (the raw data
for the performance claims above):
#lang racket/base
(module m racket/base
(require racket/contract/base)
(define (f x) x)
(provide (contract-out [f (-> any/c any/c)])))
(require 'm)
(time
(for ([x (in-range 100000)])
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)))
pre-push timings:
cpu time: 3553 real time: 3552 gc time: 52
cpu time: 3548 real time: 3552 gc time: 52
cpu time: 3525 real time: 3525 gc time: 54
cpu time: 3547 real time: 3547 gc time: 47
post-push timings:
cpu time: 515 real time: 515 gc time: 15
cpu time: 522 real time: 522 gc time: 17
cpu time: 560 real time: 560 gc time: 19
cpu time: 514 real time: 515 gc time: 19
cpu time: 507 real time: 507 gc time: 17
A second order example using vectors (note that vector/c isn't yet
updated to the #:val-first-projection, so it will be way slower)
#lang racket/base
(module m racket/base
(require racket/contract/base)
(define (f x) (vector-ref x 0))
(provide (contract-out [f (-> (vectorof any/c) any/c)])))
(require 'm)
(define v (vector void))
(time
(for ([x (in-range 10000)])
(f v) (f v) (f v) (f v) (f v) (f v) (f v) (f v)
(f v) (f v) (f v) (f v) (f v) (f v) (f v) (f v)
(f v) (f v) (f v) (f v) (f v) (f v) (f v) (f v)
(f v) (f v) (f v) (f v) (f v) (f v) (f v) (f v)
(f v) (f v) (f v) (f v) (f v) (f v) (f v) (f v)
(f v) (f v) (f v) (f v) (f v) (f v) (f v) (f v)
(f v) (f v) (f v) (f v) (f v) (f v) (f v) (f v)))
pre-push timings:
cpu time: 744 real time: 745 gc time: 20
cpu time: 679 real time: 679 gc time: 18
cpu time: 695 real time: 695 gc time: 23
cpu time: 743 real time: 742 gc time: 21
cpu time: 780 real time: 786 gc time: 21
cpu time: 723 real time: 726 gc time: 25
post-push timings:
cpu time: 448 real time: 448 gc time: 18
cpu time: 470 real time: 469 gc time: 19
cpu time: 466 real time: 465 gc time: 16
cpu time: 457 real time: 456 gc time: 15
cpu time: 465 real time: 466 gc time: 24
Using contracts in TR
#lang racket/base
(module m typed/racket/base
(: f (Any -> Any))
(define (f x) x)
(provide f))
(require 'm)
(time
(for ([x (in-range 10000)])
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)))
pre-push timings:
cpu time: 357 real time: 357 gc time: 6
cpu time: 446 real time: 447 gc time: 4
cpu time: 361 real time: 359 gc time: 4
cpu time: 366 real time: 366 gc time: 5
cpu time: 368 real time: 367 gc time: 6
post-push timings
cpu time: 63 real time: 63 gc time: 7
cpu time: 64 real time: 63 gc time: 8
cpu time: 63 real time: 64 gc time: 8
cpu time: 58 real time: 58 gc time: 8
cpu time: 59 real time: 59 gc time: 7
Slowdown for 'send':
#lang racket/base
(require racket/class)
(define c% (class object% (define/public (m x) x) (super-new)))
(define o (new c%))
(time
(for ([x (in-range 100000)])
(send o m 1) (send o m 2) (send o m 3) (send o m 4)
(send o m 5) (send o m 6) (send o m 7) (send o m 8)
(send o m 1) (send o m 2) (send o m 3) (send o m 4)
(send o m 5) (send o m 6) (send o m 7) (send o m 8)
(send o m 1) (send o m 2) (send o m 3) (send o m 4)
(send o m 5) (send o m 6) (send o m 7) (send o m 8)
(send o m 1) (send o m 2) (send o m 3) (send o m 4)
(send o m 5) (send o m 6) (send o m 7) (send o m 8)
(send o m 1) (send o m 2) (send o m 3) (send o m 4)
(send o m 5) (send o m 6) (send o m 7) (send o m 8)))
timings pre-push:
cpu time: 251 real time: 251 gc time: 0
cpu time: 275 real time: 275 gc time: 0
cpu time: 250 real time: 250 gc time: 0
cpu time: 246 real time: 246 gc time: 0
cpu time: 247 real time: 246 gc time: 0
timings post-push:
cpu time: 303 real time: 302 gc time: 0
cpu time: 333 real time: 333 gc time: 0
cpu time: 315 real time: 315 gc time: 0
cpu time: 317 real time: 317 gc time: 0
cpu time: 311 real time: 310 gc time: 0
original commit: c321f6dd0c4e2444d44b6c79a3ac49acfb9041bf
This change is slightly incompatible, because `serializable-struct`,
`define-serializable-struct`, and `define-serializable-class` no
longer `provide` and identifier that they used to. Instead, the identifier
is provided by a `deserialize-info` submodule.
The deserializer looks for a `deserialize-info` submodule, and then
falls back to using a module if the submodule is not available.
original commit: 90142edc5b4649e058ccf66970c119076ac5e864
The `mzlib/compile' module re-exports the moved function.
Also, fix `make-directory*' so that it never fails on an existing
directory. Remove `unstable/file', since it was just the same
clean-up of `make-directory*'.
original commit: 8d3c09b38b853dabffb5a58ba6a34876ca4f62fb
Remaining are:
- parts of unit200 that Matthew plans to remove.
- the `mzscheme` implementation itself.
The implementation of `mzscheme` has been moved
to the `mzscheme` collection (from the `racket` and
`scheme` collections). The `scheme/mzscheme`
language, which was undocumented, has been removed.
This is slightly backwards-incompatible, because
the `xform` handling of precompiled headers now
evaluates code in a `racket/base`-like namespace,
instead of in a `mzscheme`-like namespace.
original commit: d54c1e4e4942c26dcbaaebcc43d5c92d507a8112
- Most units and signatures from the `net` collection
are now in `compatibility-lib`.
- Most of the actual libraries are in the `net-lib`
package.
original commit: 2b1fb036c63639bc5dbb65348c4f4e5802c95b53
Left one dependency broken: "drracket" currently depends on "htdp" for
a test. That needs to be fixed by removing the dependency (moving the
test to "htdp?), instead of changing the declared dependencies.
original commit: 51290fd2a95def6bb3b6d3d735cb62444e157553
The "-lib" in "compatbility-lib" is meant to mean "no documentation"
-- and, more to the point, no dependency on documentation infrastructure.
Move later to a "compatibility-doc" package.
This reverts commit acce2d27d13a0bb2fffd4a4a5b844a2395b874f0.
original commit: 05dfce142b39e20d57598708cad501a8d9a14622
There are a number of formerly-exported identifiers that are now
no longer exported:
provide/contract-transformer?
true-provide/contract
replace-provide/contract-transformer-positive-blame
make-provide/contract-transformer
These are internal bindings that should probably never have been
exported. (They weren't documented.)
There are two currently-exported identifiers that were not
exported before:
blame-update
contract-continuation-mark-key
The first comes because mzlib/contract re-exports
racket/contract/combinator and blame-update is a new export there (for
option contracts). The other is less clear and may be hidden
(it is also new to racket/contract).
original commit: 50a058b26954d1b63fa1f1b5cd82a73540ff0c40
A package's "info.rkt" file should define `collection' as a
string to name a single-collection package's collection, or as
the symbol 'multi to declare the package as multi-collection.
If `collection' is 'same-as-pkg, then the package name is used
as the collection name.
The default for `collection' is 'multi for now, but the intent
is to change the default to 'same-as-pkg after a conversion
period. Also, support for a `single-collection' definition remains
in place, but it wil be removed.
original commit: c738a6aa3eee89a82d577dd35c70eca8ed32f5b4
The "racket" directory contains a pared-back version of the
repository, roughly.
The "pkgs" directory everything else in the repository, but
organized into packages.
original commit: b2ebb0a28bf8136e75cd98316c22fe54c30eacb2
Adds `--from-dir' and `--from-install' flags to select the interpretation
of the argument as a directory or as the name of an installed package.
Relevant to PR 13669
Adds `--as-is' (the default), `--source', and `--binary' flags to
select a pruning mode.
The `raco setup' tool recognizes a `rendered-scribblings' specification
in "info.rkt" to trigger moving rendered documentation into place,
registering its tags in the cross-reference database, and fixing up
references to "local-redirect.js"; the presence of a "synced.rktd"
indicates when those fixups have been performed (since, if the package
is installed in a user-specific scope, the documentation doesn't actually
move anywhere). Finally, "out<n>.sxref" needs to report paths relative to
the documentation's directory, and then the relative-directory references
need to be suitably resolved at derserialization; some support for such
relative paths was in place, but it wasn't quite general enough before.
original commit: 198a65a5fc79649ec167d2407c35815768a119ba
