being edited in DrRacket (via places)
Added an API to let tools have access to that
information (and compute more stuff)
Used that to make an online version of Check Syntax
which led to a separately callable Check Syntax API.
managed-compile-zo
make-caching-managed-compile-zo
make-compilation-manager-load/use-compiled-handler
that gets used when compiled files, dep files, and compiled/ directories are created.
Since sets are implemented using the elements as the domain of a hash table,
the following must be true:
* element contracts for (seteq ...) must be flat
* element contracts for (seteqv ...) must be flat
* element contracts for (set ...) must be chaperones, and the resulting
contract is a chaperone contract
Also, change higher-order set/c contracts to be chaperone contracts
due to the new restrictions.
It's not clear that any limit is still needed, and probably
font sizes should be liberalized to reals instead of
integers (but I don't want to spend that kind of time
right now).
requiring itself into the entered namespace.
This makes it useful in some cases where this require leads to a
dependency cycle, eg (enter! racket/list). It's obviously not useful
for use as-is, since you will not have a bound `enter!' to get out of
the namespace (and possibly no `require' to get it) -- but it is useful
for meta-tools like xrepl. This is why the flag is verbose. `xrepl'
now uses this flag.
Also, the check for valid keywords for the form is now done at runtime
rather than in the macro. This doesn't matter in this case, since the
form is intended for interactive use anyway.
Also, separate the two parts of `enter-load/use-compiled' (it was
defined curried, but didn't use it).
Use the new functions in `syntax-case'; the benefit is small, and
it's mostly useful as hint to the optimizer that the operation
can be dropped if the result isn't used
`setup/private/path-utils'.
The API is a little different: instead of getting the alist and the
path, there's a curried function that gets the alist and produces a
function to do the substitutions.
`setup/path-relativize'.
`setup/path-relativize' is freed from a bunch of things that were due to
historical baggage, but some remain. (Also, update its docs.)
* Lists are now either blocks or splices depending on whether they
appear inside a block or a splice (default to block).
* Adjusted the docs and a single test where this mattered.
* Change the documentation to be "text.html" and to be titled "text
generation".
I originally picked "under" as the preposition to go before
a platform name, but obviously you should build "on" a
platform, and "under" suddenly annoys me. The choice of "on"
is now codified in the documentation style guide. Meanwhile,
"Unix" insted of "X" seems more clear and consistent in the
`racket/gui' docs.
More usefully, this patch also fixes a few out-of-date
platform-specific claims.
Revert "Fix interface."
Revert "Add more scribble forms that evaluate code and display the results."
This reverts commit a621eaf041.
This reverts commit 7e9dbded4c.
by default; a new optional argument restores the old behavior
(but the default behavior is consistent with the old docs and with
the vast majority of existing uses)
The implementation is ugly for performance reasons. A new primitive
`prop:arity-incomplete' property determines when to return #f for
`procedure-arity-includes?' in default mode. A nicer implementation
would be to redefine `procedure-arity-includes?' at the kw-proc level,
but the bytecode optimizer's and JIT's treatment of the built-in
`procedure-arity-includes?' is important. The implementation choice
could be revisited after cross-module inlining is implemented.
Closes PR 11978
The new version fixes some problems with the previous one, most notably
it can create a keyworded function when the last input is is keyworded.
`compose1' is a restricted variant that requires single values in the
composed pipeline -- besides being potentially faster (probably more
if/when there is cross module inlining), it has a semantical
justification, similar to the restricting function call arguments to
return single values, with similar robustness benefits. The
implementation of both is done in a generalized way, and the results can
be faster for both `compose' and `compose1'. (Not by much -- 20% and
30% resp.)
One thing that it could do is to reduce the resulting arity to match the
last given function. I didn't do this since it adds a significant
overhead to the result. (No strong opinion on doing that...)
