The new predicates are `progress-evt?' `thread-cell-values?',
`prefab-key?', `semaphore-peek-evt?', and `channel-put-evt?'.
These were used internally, and now they appear in contract
error messages.
When supplying an accessor to redirect, either the corresponding field
must be accessible through the current inspector, or a mutator for
the same field must be redirected, too.
Stevie realized that we need this constraint; otherwise, impersonators
can implement mutator-like behavior even when the mutator is otherwise
secret.
This change does not yet update the *SL error-message rewriter
to recognize the new error-message formats; the tests do not
currently use the rewriter. A next step is to decide on the
rewritings, implement them, change the test suite to use the
rewriter, and test the rewritings.
Add `raise-argument-error', `raise-result-error', `raise-arguments-error',
and `raise-range-error'.
The old convention was designed for reporting on a single (sometimes very
long line). The new convention is
<name>: <short message>
<field>: <detail>
...
If <detail> is long or itself spans multiple lines, then it may
also use the form
<field>:
<detail>
where each line of <detail> is indented by 3 spaces.
Backtrace information is shown as a multi-line "context" field.
Committed as a checkpoint, since I convinced myself that a single
function with a keyword is better, given that the rest of the simplified
functions operate on the whole string.
The text that says that (regexp-split #rx"whatever" "") returns '("")
rather than '() is
If `input' contains no matches [...] the result is a list containing
input’s content [...] as a single element.
This is a little implicit, if you consider such an input as having
nothing left to match over so it's as if there is no input (with a port
this confusion is a little clearer).
Clarify with an example in the docs, and also add tests.
Since mixins rely on super calls to possibly abstract
methods, we want to ensure that the super call will not
error when it gets to an abstract method. However,
external method calls should still raise an error for
abstract methods.
The properties appear in the inlining expansion of an application
of a keyword-accepting function, and they're mainly intended for
use by Typed Racket.
The property keys are hidden, so that the property value can be
trusted as originating from `racket/base'. The accessor functions are
`syntax-procedure-alias-property' and
`syntax-procedure-converted-arguments-property' from
`racket/keyword-transform'.
For example, if definitions have two unmarked `x's that originate
from different modules, make them correspond to different bindings.
This improvement will be used by `scribble/srcdoc', which will
rely on module context to connect `for-doc' requires to documentation
code that appears in the same module --- which is needed, for example,
if a macro expands to documentation code and the macro is used in
a different module.
(this is similar to being flat, but struct contract (lazy ones) can
be non-flat and still have no negative blame).
Use this to optimize struct/dc contracts; specifically when a contract
has no negative blame, then we don't need to add additional wrapping
for indy-ness.
This ended up being fairly tricky to handle the case where there
are several mutually recursive define-opt/c functions. The code
tracks which definitions depend on which ones and does a graph traversal
of the dependencies to find if there is any non-negative blame
possible. Naturally, this uses Racket's macro system to communicate
between the definitions.
This reverts commit f3b687c8ed.
After discussion with Robby and Stevie, we concluded that
this procedure isn't necessary for now. If we ever think
of more examples where it's useful we can bring it back.
a chaperone contract", "no it definitely isn't" or "evaluate this code
at runtime to find out"; previously only the first two options
were available to opters
(this commit also includes other tweaks here and there so won't stand alone)
Looks like it's not making any changes in the current tests (which use
the text renderer), but with words that are longer than the width the
old version would stop wrapping afetr these words. Added a test file
that fails with that and succeeds with the new one. If anyone cares
about this, it's easy to make hyphenate words that are too long for a
line.
(Also fixed some redundant frustration in the bib test...)
* Make each test file runnable using `module+'.
* Make the space tests not print anything (unless they fail, of course).
* Make the `first-class?' case even "more first class" by defining their
and/or as functions. (Doesn't make a real difference for this test,
but nice to test more of the language.)
This should probably become documented if it's stable enough. For now
it's intended for building wrapping functions, so it's only documented
in comments the file.
Don't put an extra seperator element at the end of the stream. Brings
it in-line with the list version (`add-between') and sequence
version (`sequence-add-between'). Includes a test.
* Use #f instead of (lambda () #f) in hash-ref call
* We want the positive blame, not negative, when interface-contracted
methods are passing through a class/c application.
* Use (interface <i>) and (class <c>) for interface and class blame.
