This means that `*gc-priority*` scripts will now reliably run last.
Prior to this change, if some higher-priority script X ran while a
`*gc-priority*` script Y was queued, and it enqueued a high-priority
script Z, then Y would run before Z.
This is a major change to the previous design, and also a change with
respect to the semantics in the ESOP 2016 paper. All the complexity of
echo-cancellation is stripped out of the core dataspace semantics, and
the relaying protocol is changed from one constructor, `at-meta`, to
two, `inbound` and `outbound`. The relay connecting a dataspace to its
container is now completely symmetric with the contained actors: it
initially asserts interest in what it is to relay, just like any other
actor would. Dataspaces no longer treat relaying specially.
This commit has updated all (I think) of the non-graphical examples. The
graphical code remains to be done in a following commit.
A store is like a parameter, except stores are independent of each
other, unlike parameters which are bundled together into a single
parameterization. This was observable in cases like the
example-action-after-suspension code checked in here, where dataflow
invoked a script, which parameterized current-dataflow-subject-id.
This captured *too much* of things like the pending-patch and
pending-actions. Subsequent `schedule-action!` calls' effects were
then lost.
Introduced expanders for events (define-event-expander) and for
assertion-patterns (define-assertion-expander).
Introduced convenience syntax and utilities in web.rkt for working
with web requests.
Support nested bindings in assertion-patterns for message events
(only).
Adding `#'module+` explicitly to the stop-list for local-expand stops
the infinite recursion (problem 1 in the issue description). The code
goes on to treat it like `#'module` and `#'module+`, namely as a
non-action-producing form.
Problem 2 in the issue description is interesting. I haven't done
anything in particular to address the production of unbounded `X` ->
`(begin X)` expansions, but it seems not currently to be a problem;
and, weirdly (?), submodules in a `#lang syndicate` or `#lang
syndicate/actor` module do not seem to inherit the `#%module-begin` of
their container! That is, `(module+ main)`, `(module+ test)` etc. all
seem to have a `racket/base` `#%module-begin`, though I've not looked
very far into this.
Most peculiar on this front is that if the `#,@(reverse final-forms)`
precedes the `(module+ syndicate-main ...)`, and the module being
processed includes, say, a `(module+ main)`, then for some reason the
resulting `main` submodule *is* treated as having a `syndicate/lang`
`#%module-begin` (thus causing problems as suggested in the issue
description)! I *really* don't understand why that might be, and
haven't spent very much time investigating after I noticed that so
long as the `main`-required `syndicate-main` submodule preceded all
other submodule declarations, things seemed to work out.
This whole approach is still a bit dicey: for example, the following
will erroneously treat `(foo quux)` as an expression yielding actions,
rather than a struct declaration:
#lang syndicate
(define-syntax-rule (foo x) (struct x ()))
(foo quux)
This makes rising-edge checks happen only when *fields* change, rather
than every turn. It also means that if a script causes a relevant
field change, the rising-edge check will definitely be performed
before the end of the turn.
A potential downside is that a rising-edge check could schedule a
script which triggers the same rising-edge check, causing an infinite
loop in `run-scripts!`.
Make #lang syndicate module-begin gather boot actions into a
syndicate-main submodule, and for each such module, add a main
submodule that calls run-ground with the syndicate-main boot actions.
This lets us write syndicate *libraries* that comprise both
data-structures, functions, and Syndicate services.
This is Syndicate/Racket v2, modeled more closely after Syndicate/js.
Facets and Endpoints are now contained within a single actor, unlike
Syndicate/Racket v1, where a linkage protocol between multiple actors
was used. The approach to actor and facet state has been revised as a
consequence.
Almost all the examples using syndicate/actor have been updated.
Tony Garnock-Jones
Sam Caldwell