I found the text as written slightly misleading. The phrase "referenced by a value" intends to describe a state of being; generally, a value *is* a reference. One might misinterpret this English phrase, though, as describing an action that can occur: "reference" being an action that a value can perform, like "walk", "jump", or "skip". Further, because objects aren't limited to holding merely those data that some variable references, I thought it improved reading to remove that qualification.
I imagine a reader misunderstanding the causal relationship in the sentence as currently written. I hope for this to disambiguate. I believe this point in the document describes a design decision we the reader are presently considering. The reader should not imagine that an existing capacity to change `x` itself materially /prevents/ substitution---that we cannot substitute---the way a buoy's ability to float prevents it from sinking. I believe the writer means to say that the intended goal, supporting mutation, makes us (the author + the reader) reject direct substitution as an evaluation strategy.
When a glib message is logged in an OS thread not created by Racket,
then the current-future and async-callback-queue thread-local
variables were not initialized. The failure mode tended to be an
unending and memory-consuming cycle of triggering an error while
attempting to report an error.
Although there was a test for proper handling of logging calls from
foreign threads, the test previously created the "foreign" thread with
`call-in-os-thread`, which is not foreign enough.
Related to #3832
That way, a mutex or conditional variable can be referenced by
something else that has a finalizer and that might use the mutex or
condition variable.
Closes#3842
Add `record-ptr-offset` so that rktboot can use that instead of
assuming an offest of 1.
Also, introduce `type-untyped` and use it instead of `typemod` when
the intent is to leave an address unchanged by tagging. That makes the
implementation a little clearer, and it reduces the code that would
have to be changed to modify the tagging discipline (e.g., to tag by
adding instead of subtracting from an address).
Previously, the `raco setup` step would use `--user` and
`--avoid-main` when the scope was not specifically `installation`.
Change it to instead use those when the scop is specifically `user`.
That makes additional scopes treated more like an installation scope
than a user scope, which is consistent with how `raco setup` treats
things (i.e., link paths that are in the search path).
Overall, it seems that the idea of just layering packages in extra
scopes does not work out, and the layering needs to be built in more
deeply. That's what recent improvements for layering do. But this
change at least makes `raco pkg` and `raco setup` more consistent.
Thanks to Nate Griswold for drawing out this issue.
When a layer renders new documentation that refers to a previous
layer, the redirection script was not generated as needed to reach
the previous layer.
The documentation currently implements less sharing that would be
possible across layers. For each installation layer, `raco setup`
duplicates the documentation database in "docindex.sqlite", and it
duplicates the search index, and it duplicates the local-redirection
index. That duplication avoids having to join across an an arbitrary
number of SQLite databases or chain the search and local-redirection
indexes.
Various "config.rktd" options are meant to support creating layers of
installation that builds existing layers. Configuration options also
supports a "tethering" mode that makes `raco setup` create launchers
that bind to the configration (so an environment variant doesn't have
to be set). While several pieces of this idea were in place in commit
6369e56709, it wasn't really finished, and there was no documentation
to explain how things are intended to work.
There's definitely still room for tools that automate the steps for
setting up a layer and tethering.
Along the way, this commit cleans up the `(find-system-path
'exec-file)` aspect of embedding executables as launchers to make them
consistent across platforms and work right as tethered launchers.
