* See comment about implementation issues.
* Removed the `list?' requirement on `takef' etc -- so it matches the
non-*f versions. (IMO, it'd be better to drop it from all of them.)
This also changes the output of `dropf' to `any/c'.
* Swapped the argument order so the predicate is last -- this makes it
uniform with the non-f* versions. (IMO, it'b be better to use the
popular order in all of them instead.)
* Includes tests, and also improved version of previous tests.
* Includes docs, and also fixes to previous docs (eg, drop* doesn't
return a fresh list).
* Check `sandbox-path-permissions' for bad values such as
'(<perm> <path1> <path2>) where <path2> would get silently ignored.
* Try to clarify the intent of `call-in-sandbox-context' as a meta tool
rather than a safe execution tool.
The intent is to support phase-crossing data such as the `exn:fail:syntax'
structure type that is instantiaed by macros and recognized by contexts
that use `eval' or `expand'. Phaseless modules are highly constrained,
however, to avoid new cross-phase channels, and a module is inferred to
be phaseless when it fits syntactic constraints.
I've adjusted `racket/kernel' and improved its documentation a little
so that it can be used to implement a phaseless module (which can
import only from other phaseless modules).
This change also adds a `flags' field to the `mod' structure type
from `compiler/zo-structs'.
wrap/handle-evt that receives multiple values must have a handler function with adequate arity.
struct.c:
change contract for wrap/handle-evt from (any/c -> any) to procedure?
thread.c:
adjust sync processing
sync.rktl:
add test for handle-evt, wrap-evt and prop:evt
An extflonum is like a flonum, but with 80-bit precision and
not a number in the sense of `number?': only operations such as
`extfl+' work on extflonums, and only on platforms where extflonums
can be implemented by hardware without interefering with flonums
(i.e., on platforms where SSE instructions are used for
double-precision floats).
[Patch provided by Michael Filonenko and revised by Matthew.]
The compiler tracks information about bindings that are known to
hold extflonums, but the JIT does not yet exploit this information
to unbox them (except as intermediate results).
This guarantees that patterns like (? pred pat) will
always check `pred` before matching any of `pat`.
However, `and` patterns are not required to match left-
to-right.
The synchronization result of a log receiver is now a vector of four
values, instead of three, where the last one reports the name.
Also, an optional argument to `make-logger' provides a notification
callback for each event sent to the logger.
These changes enable more control over loggers and events. Suppose
that you have processes A and B, and you want all log events of A
to be visible to B, but not vice-versa. Furthermore, you want the
log events to appear at B in the right order: if A logs an event
before B, then A's event should arrive at a log receiver's before
B's. Now that a log receiver gets the name associated with the
original event, and now that the name can be re-sent in a
`log-receiver', it's possible to give A and B separate loggers and
send all of the events from A's logger to B's logger. Furthermore,
you can use the notification callback so that when an event is logged
in B, you can make sure that all available events from from A's
logger have been transferred to B's logger.
