Plus minor cleanups:
- fixed indentation
- removed useless gen-create-place function
- avoid using the guard position of syntax-case
- drop useless datum->syntax call (it returns syntax
objects unmodified and generate-temporary
returns a syntax object)
- "interal" => "internal"
- minimized the generated code (move into a function call)
- check to make sure constructed lambda expression is well-formed
- check to make sure 'place' is used inside a module (or else
several other things it use will fail)
One example use is the handin server, where the ssl library
is needed to run some programs in my class. (I didn't figure
out exactly why, but it seems reasonable.)
* When `accept-lang?' is #t turn the reader flag on, but otherwise don't
change it
* turn on the `read-accept-reader' flag which is needed after all
* two refactoring typos
* some more reformatting
Shared locking now allowed only on input port, and exclusive
locking is allowed only on output ports, which allows an implementation
via fcntl(...,F_SETLK,...).
When `define' binds a keyword procedure at the top level or module
level, then it actually binds syntax that checks (i.e., warns
if arith or keywords are bad) and optimizes (i.e., avoids checking
keywords or allocating keyword-argument lists) first-order uses of
the procedure.
Checking and conversion are currently only performed for top-
and module-level bindings, because some macros detect the difference
between a variable or syntax definition --- notably `class' and
`unit'. A related problem in `class' is that the expansion
produces multiple definitions (for direct access to the fast
version of the function), which `class' turns into fields instead
of methods.
With the JIT, the `reverse' function is significantly faster,
while the `member' variants do not really change; the main
benefit is that the operations play well with futures.
The C implementation is still used when the JIT is unavailable,
since the Racket implementations can be much slower in
interpreted mode.
