Altered TR's random arithmetic testing to generate single-flonums and very small flonums; fails now because of erroneous types
Fixes to sgn, sinh, cosh, and tanh:
* preserve single-flonum-ness
* correct zero sign (-0.0) for negative return values that are smaller than epsilon
* correct behavior with NaN and infinite inputs
Caveats:
- keyword function definitions do not define static
bindings, thus limiting optimization opportunities
- can't use `define:`, `lambda:`, etc with keywords
- error messages sometimes expose the implementation
- the optimizer skips most of the generated code for
keyword functions definitions (user-level code is
optimized)
Also, fix FFI procedures to preserve names: change `ptr-ref' with
`_fpointer' on an `ffi-obj' value to return the `ffi-obj'
value, so that the name in the `ffi-obj' value can be used
by `_cprocedure'.
Closes PR 12645
Previously, some hacks were used to obtain the internal
identifiers that implemented keyword functions directly, and
give them types at startup. Now, the primary "function"
(eg, `sort`) is given a type, and when used, the residual
syntax properties are used to find `sort` from the real
functions, and then the type of the real function is computed
from the type of `sort`.
Some creativity was required in the types of functions which
take optional arguments that when present, alter the return type,
such as `regexp-match*` and `file->list`.
like textual-read-eval-print-loop
There is still a difference, however, because drracket's REPL has a
notion of multiple expressions that are submitted simultaneously that
textual-read-eval-print-loop doesn't. For example, if you type this at
the prompt:
(car) (+ 1 2)
then textual-read-eval-print-loop will print out the error and then 3,
but drracket will print only the error (ditto if (car) were replaced
by a continuation abort).
This difference is, IMO, a good thing, since it lets you use a single
interaction to do multiple things, but stops as soon as there is an
error. (It is also how drracket has behaved for a long time.)
closes PR 12790
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.
These primitives atomically update a box to a new value, as long
as the current value is the same as a provided value. They also
are future-safe.
When futures are enabled, they use low-level hardware instructions
to perform the change atomically.
Also, use keywords for `make-pen' and `make-brush'.
Adding `make-pen' and `make-color' creates many conflicts among
teaching libraries, such as `2htdp/image'. These are easy to fix
up in the tree, but adding such obvious names to `racket/draw'
may create other compatibility problems, so we might have to reconsider
the names.
In consultation with Asumu.
Generate wrappers consistent with a reader-level absence of `.'s,
instead of wrapping every pair. This change fixes the `syntax-e'
example in the Guide's description of syntax objects.
The preserved path is exposed by a new `module-path-index-submodule'
function, and `module-path-index-join' now accepts an optional
submodule path.
Also, fixed a problem with `collapse-module-path-index' when
a module path indx is built on a resolved module path that
is a submodule path.
In addition to the main repair, `collapse-module-path[-index]' is
correctly documented to allow '(quote <sym>) rel-to paths.
Finally, `collapse-module-path-index' changed to use a symbolic
resolved module path that appears as the base of a module path
index, rather than falling back to the given rel-to path. It's
possble that the old beavior was intentional, but it wasn't tested,
and it seems more likely to have been a bug.
Closes PR 12724
For example, `(module-declared? '(submod (planet dyoo/bf) reader) #t)'
shouldn't fail if there's no "main.rkt" to hold a `reader' submodule;
it should return #f.
Merge to 5.3, but updating cstartup.inc will require a manual merge.
MySQL:
- support multi-packet data rows
- fixed very old length-coding bug (24 vs 32 bit length)
- support large params via long-data packets
- 'any' pseudo-type for parameters
- distinguish 'blob'/'text', 'var-string'/'var-binary'
- read 'text' results as string, not bytes
SQLite3:
- enabled sql types tests
library (mostly in opt/c)
Specifically:
- add inlining declaration for ->i helper function
- modernized the opt/c contracts and improved them so that mutually
recursive define-opt/c functions recognize each other instead of
bailing out to the slow path.
- added =/c as an optimized contract
- improve the error message for the between and comparison opt
contracts
- adjust the blame struct so the name is created lazily, since opt/c
contracts just stick a copy o the contract into the thunk that
creates the name and we don't want to run those effects twice if we
can help it.
adjust 'one-of/c' and 'symbols' so they just use or/c (when possible)
improve or/c's stronger check so that, in the case that or/c is
getting eq or equal contracts, or/c's stronger check is as good as
'symbols'/'one-of/c's stronger check is.
This distinction is important after the introduction of chaperones and
impersonators, since accessing a key and accessing its corresponding value
may have different effects, and hash-keys should only trigger the former.
The immediate symptom was that `(provide (all-defined-out))'
didn't work in a `module+'-based submodule, but there were
also non-submodule ways to expose the problem.
The `get-handle' method provides the underlying Cairo surface for
a bitmap, while the unsafe `make-handle-brush' function supports the
use of a Cairo surface as a `brush%'.
Also, add `racket/draw/unsafe/cairo-lib', which simplifies access
Cairo from external libraries. Documenting `racket/draw/unsafe/cairo'
might be better, but that's a lot more work.
* Get rid of the concept of `modspec': `getarg' now has `require' for
require specs and `module' for a module name (the latter is what all
previous uses of 'modspec except for ,require really needed); command
descriptions use "<require-spec>" and "<module>", documentation
adjusted as well.
* `module-name?' etc turn to `known-module' and `known-module-name',
with a saner behavior, and tests to keep it sane.
* This cleans up a lot of things. Two specific points: ,switch works
better with toplevel-defined modules (see the corresponding change in
the test suite), and also fixes PR 12148.
* Ensure that ,sh commands return void.
* Add tests for ,r with non-atomic require spec, and for use of $F in
,sh commands.
* Improved the test suite, including uses of `module+' so each file can
be run by itself to perform a subset of the tests.
- changed substitute to use closure-compilation
- added stress/perf test for templates
- updated minimatch with vector patterns
- split substitute into separate file, minimize dependencies
- do ellipsis optimization dynamically
- validate guides: check var indexes
It looks like run-teaching-program hasn't been touched in quite a while.
To begin with, the "rewrite-module" function used to add code to print
out values of non-define exprs, but this is no longer necessary. In fact,
the only thing that it does now is to discard "provide" statements, and
even this may be unnecessary. I rewrote big chunks of this (short) file
to introduce defines, eliminate unnecessary functions, and add stepper-
skip-completely annotations to the requires associated with teachpacks.
Also, it appears that the 'rep' argument to expand-teaching-program
was entirely superfluous; I removed it from the argument list, and also
from the three places in the main tree (deinprogramm, lang, and the stepper)
that call this function.
Let me know of any problems seen with teachpack requires....
The bug happens with n-ary uses of arithmetic operations that
have constant arguments but couldn't be constant-folded ---
maybe due to a divide-by-zero.
