702df4b07a
It was pulling from `scheme/gui/base', instead. The one from `scheme/gui/base' is now different and still pulls from `scheme/gui/base'. This could break some programs that accidentally depended on `scheme/gui/base' exports from `gui-dynamic-require', but it's more likely to fix problems.
398 lines
15 KiB
Racket
398 lines
15 KiB
Racket
#lang scribble/manual
|
|
@(require (for-label (only-in scheme/foreign unsafe! provide* define-unsafer)
|
|
(only-in scheme/base make-base-namespace make-base-empty-namespace)
|
|
(only-in scheme/pretty pretty-print)
|
|
(only-in racket/pretty pretty-write)
|
|
(only-in scheme/class printable<%>)
|
|
(only-in racket/class writable<%>)
|
|
(only-in racket/base struct hash hasheq hasheqv in-directory local-require)
|
|
(only-in racket/unit struct/ctc)
|
|
(only-in scheme/gui/base make-gui-namespace make-gui-empty-namespace)
|
|
(only-in scheme/gui/dynamic gui-dynamic-require)
|
|
(only-in mzlib/unit struct~s struct~s/ctc)
|
|
scheme/gui/base
|
|
scheme/sandbox))
|
|
|
|
@(define-syntax-rule (def-extras unit-struct
|
|
unit-struct/ctc
|
|
make-base-namespace-id
|
|
make-base-empty-namespace-id
|
|
sandbox-namespace-specs-id
|
|
make-evaluator-id
|
|
make-module-evaluator-id
|
|
pretty-print-id
|
|
printable<%>-id
|
|
gui-dynamic-require-id)
|
|
(begin
|
|
(require (for-label (only-in scheme struct struct/ctc)
|
|
(only-in racket/base make-base-namespace
|
|
make-base-empty-namespace)
|
|
(only-in racket/pretty pretty-print)
|
|
(only-in racket/gui/dynamic gui-dynamic-require)
|
|
racket/sandbox))
|
|
(define unit-struct (racket struct))
|
|
(define unit-struct/ctc (racket struct/ctc))
|
|
(define make-base-namespace-id (racket make-base-namespace))
|
|
(define make-base-empty-namespace-id (racket make-base-empty-namespace))
|
|
(define sandbox-namespace-specs-id (racket sandbox-namespace-specs))
|
|
(define make-evaluator-id (racket make-evaluator))
|
|
(define make-module-evaluator-id (racket make-module-evaluator))
|
|
(define pretty-print-id (racket pretty-print))
|
|
(define printable<%>-id (racket printable<%>))
|
|
(define gui-dynamic-require-id (racket gui-dynamic-require))))
|
|
@(def-extras unit-struct
|
|
unit-struct/ctc
|
|
make-base-namespace-id
|
|
make-base-empty-namespace-id
|
|
sandbox-namespace-specs-id
|
|
make-evaluator-id
|
|
make-module-evaluator-id
|
|
pretty-print-id
|
|
printable<%>-id
|
|
gui-dynamic-require-id)
|
|
|
|
@(define-syntax-rule (compat-except sid rid . rest)
|
|
(begin
|
|
@section[@racketmodname[sid]]
|
|
@defmodule[sid]
|
|
"The " @racketmodname[sid] " library re-exports " @racketmodname[rid] (begin . rest) "."))
|
|
@(define-syntax-rule (compat sid rid)
|
|
(compat-except sid rid))
|
|
|
|
@title{Scheme: Compatibility Libraries and Executables}
|
|
|
|
Racket was once called ``PLT Scheme,'' and a number of libraries with
|
|
names starting @racketidfont{scheme} provide compatibility with the
|
|
old name. A few @seclink["compat-exe"]{old executables} are also provided.
|
|
|
|
Do not use @racketmodfont{#lang} @racketmodname[scheme] to start new projects;
|
|
@racketmodfont{#lang} @racketmodname[racket] is the preferred language.
|
|
|
|
@table-of-contents[]
|
|
|
|
@compat-except[scheme racket]{, except based on @racketmodname[scheme/base]
|
|
instead of @racketmodname[racket/base], the @|unit-struct| and @|unit-struct/ctc| from
|
|
@racketmodname[scheme/unit] is exported, @racketmodname[scheme/set] is
|
|
not re-exported, @racketmodname[scheme/system] is
|
|
not re-exported, @racket[pretty-print] is re-directed in as
|
|
@racketmodname[scheme/pretty], and @racketmodname[scheme/nest] is
|
|
re-exported}
|
|
|
|
@compat-except[scheme/base racket/base]{, except that
|
|
@racketmodname[racket]'s @racket[struct], @racket[hash],
|
|
@racket[hasheq], @racket[hasheqv], @racket[in-directory], and
|
|
@racket[local-require] are not exported, and
|
|
@racket[make-base-namespace] and @racket[make-base-empty-namespace]
|
|
are different}
|
|
|
|
@defproc[(make-base-empty-namespace) namespace?]{
|
|
|
|
Like @|make-base-empty-namespace-id| from @racketmodname[racket/base],
|
|
but with @racketmodname[scheme/base] attached.}
|
|
|
|
@defproc[(make-base-namespace) namespace?]{
|
|
|
|
Like @|make-base-namespace-id| from @racketmodname[racket/base], but
|
|
with @racketmodname[scheme/base] attached.}
|
|
|
|
|
|
@compat[scheme/async-channel racket/async-channel]
|
|
@compat[scheme/bool racket/bool]
|
|
|
|
@; ----------------------------------------------------------------------
|
|
|
|
@compat-except[scheme/class racket/class]{, except that
|
|
@racket[writable<%>] is exported under the name @racket[printable<%>]
|
|
(and @|printable<%>-id| from @racketmodname[racket/class] is not
|
|
exported)}
|
|
|
|
@defthing[printable<%> interface?]{
|
|
|
|
An alias for @racket[writable<%>].
|
|
}
|
|
|
|
@; ----------------------------------------------------------------------
|
|
|
|
@compat[scheme/cmdline racket/cmdline]
|
|
@compat[scheme/contract racket/contract]
|
|
@compat[scheme/control racket/control]
|
|
@compat[scheme/date racket/date]
|
|
@compat[scheme/dict racket/dict]
|
|
@; @compat[scheme/fasl racket/fasl]
|
|
@compat[scheme/file racket/file]
|
|
@compat[scheme/fixnum racket/fixnum]
|
|
@compat[scheme/flonum racket/flonum]
|
|
|
|
@; ----------------------------------------------------------------------
|
|
|
|
@compat-except[scheme/foreign ffi/unsafe]{,
|
|
@racketmodname[ffi/unsafe/cvector], and @racketmodname[ffi/vector],
|
|
except that @racket[unsafe!] must be used to import the unsafe
|
|
bindings of @racketmodname[ffi/unsafe] and @racketmodname[ffi/unsafe/cvector]}
|
|
|
|
@defform[(unsafe!)]{
|
|
|
|
Makes unsafe bindings available.}
|
|
|
|
|
|
@defform/subs[#:literals (unsafe rename-out)
|
|
(provide* provide-star-spec ...)
|
|
([provide-star-spec (unsafe id)
|
|
(unsafe (rename-out [id external-id]))
|
|
provide-spec])]{
|
|
|
|
Like @racket[provide], but @racket[id]s under @racket[unsafe] are not
|
|
actually provided. Instead, they are collected for introduction into
|
|
an importing module via a macro created by @racket[define-unsafer].}
|
|
|
|
@defform[(define-unsafer id)]{
|
|
|
|
Cooperates with @racket[provide*] to define @racket[id] as a
|
|
@racket[unsafe!]-like form that introduces definitions for each
|
|
binding provided as @racket[unsafe]. The @racket[define-unsafer] form
|
|
must occur after all the @racket[provide*] forms to which it refers.}
|
|
|
|
@; ----------------------------------------------------------------------
|
|
|
|
@compat[scheme/function racket/function]
|
|
@compat[scheme/future racket/future]
|
|
@compat[scheme/generator racket/generator]
|
|
|
|
@; ----------------------------------------------------------------------
|
|
|
|
@compat-except[scheme/gui racket/gui]{, except that it builds on
|
|
@racketmodname[scheme/gui/base] instead of @racketmodname[racket/gui/base]}
|
|
|
|
@; ----------------------------------------------------------------------
|
|
|
|
@compat-except[scheme/gui/base racket/gui/base]{, except that it builds on
|
|
@racketmodname[scheme] instead of @racketmodname[racket]}
|
|
|
|
@defproc[(make-gui-empty-namespace) namespace?]{
|
|
|
|
Like @racket[make-base-empty-namespace], but with
|
|
@racketmodname[scheme/class] and @racketmodname[scheme/gui/base] also
|
|
attached to the result namespace.}
|
|
|
|
@defproc[(make-gui-namespace) namespace?]{
|
|
|
|
Like @racket[make-base-namespace], but with @racketmodname[scheme/class] and
|
|
@racketmodname[scheme/gui/base] also required into the top-level
|
|
environment of the result namespace.}
|
|
|
|
@; ----------------------------------------------------------------------
|
|
|
|
@compat-except[scheme/gui/dynamic racket/gui/dynamic]{, except
|
|
that @racket[gui-dynamic-require] extracts bindings from @racket[mred]
|
|
instead of @racket[scheme/gui/base]}
|
|
|
|
@defproc[(gui-dynamic-require [sym symbol?]) any]{
|
|
|
|
Like @|gui-dynamic-require-id| from @racket[racket/gui/base], but
|
|
to access exports of @racketmodname[scheme/gui/base].}
|
|
|
|
@; ----------------------------------------------------------------------
|
|
@compat[scheme/help racket/help]
|
|
@compat[scheme/include racket/include]
|
|
@; ----------------------------------------------------------------------
|
|
|
|
@compat-except[scheme/init racket/init]{, except that it builds on
|
|
@racketmodname[scheme] instead pf @racketmodname[racket]}
|
|
|
|
@;------------------------------------------------------------------------
|
|
|
|
@section[#:tag "scheme/language-info"]{@racketmodname[scheme/language-info]}
|
|
|
|
@defmodule[scheme/language-info]{
|
|
The @racketmodname[scheme/language-info] library is like
|
|
@racketmodname[racket/language-info], except that it produces
|
|
@racket['(#(scheme/runtime-config configure #f))] for the
|
|
@racket['configure-runtime] information key.}
|
|
|
|
See also @racketmodname[scheme/runtime-config].
|
|
|
|
@;------------------------------------------------------------------------
|
|
|
|
@compat[scheme/list racket/list]
|
|
@compat[scheme/load racket/load]
|
|
@compat[scheme/local racket/local]
|
|
@compat[scheme/match racket/match]
|
|
@compat[scheme/math racket/math]
|
|
@compat[scheme/mpair compatibility/mlist]
|
|
|
|
@;------------------------------------------------------------------------
|
|
@section[#:tag "nest"]{@racketmodname[scheme/nest]}
|
|
|
|
@defmodule[scheme/nest]
|
|
|
|
@defform[(nest ([datum ...+] ...) body ...+)]{
|
|
|
|
Combines nested expressions that syntactically drift to the right into
|
|
a more linear textual format, much in the same way that @racket[let*]
|
|
linearizes a sequence of nested @racket[let] expressions.
|
|
|
|
For example,
|
|
|
|
@racketblock[
|
|
(nest ([let ([x 10]
|
|
[y 6])]
|
|
[with-handlers ([exn:fail? (lambda (x) 15)])]
|
|
[parameterize ([current-output-port (current-error-port)])]
|
|
[let-values ([(d r) (quotient/remainder x y)])])
|
|
(display (+ d r)))
|
|
]
|
|
|
|
is equivalent to
|
|
|
|
@racketblock[
|
|
(let ([x 10]
|
|
[y 6])
|
|
(with-handlers ([exn:fail? (lambda (x) 15)])
|
|
(parameterize ([current-output-port (current-error-port)])
|
|
(let-values ([(d r) (quotient/remainder x y)])
|
|
(display (+ d r))))))
|
|
]
|
|
|
|
The @racket[nest] form is unusual in that it has no semantics apart
|
|
from its expansion, and its implementation is easier to understand
|
|
than a precise prose description:
|
|
|
|
@racketblock[
|
|
(define-syntax nest
|
|
(syntax-rules ()
|
|
[(nest () body0 body ...)
|
|
(let () body0 body ...)]
|
|
[(nest ([form forms ...]) body0 body ...)
|
|
(form forms ... (let () body0 body ...))]
|
|
[(nest ([form forms ...] . more) body0 body ...)
|
|
(form forms ... (nest more body0 body ...))]))
|
|
]}
|
|
|
|
@; ----------------------------------------
|
|
|
|
@compat[scheme/package compatibility/package]
|
|
@compat[scheme/path racket/path]
|
|
@compat[scheme/port racket/port]
|
|
|
|
@; ----------------------------------------
|
|
|
|
@compat-except[scheme/pretty racket/pretty]{, except that
|
|
@racket[pretty-write] is exported under the name @racket[pretty-print]
|
|
(and @|pretty-print-id| from @racketmodname[racket/pretty] is not
|
|
exported)}
|
|
|
|
@defproc[(pretty-print [v any/c] [port output-port? (current-output-port)])
|
|
void?]{
|
|
|
|
An alias for @racket[pretty-write].}
|
|
|
|
@; ----------------------------------------
|
|
|
|
@compat[scheme/promise racket/promise]
|
|
@compat[scheme/provide racket/provide]
|
|
@compat[scheme/provide-syntax racket/provide-syntax]
|
|
@compat[scheme/provide-transform racket/provide-transform]
|
|
@compat[scheme/require racket/require]
|
|
@compat[scheme/require-syntax racket/require-syntax]
|
|
@compat[scheme/require-transform racket/require-transform]
|
|
|
|
@;------------------------------------------------------------------------
|
|
|
|
@section[#:tag "scheme/runtime-config"]{@racketmodname[scheme/runtime-config]}
|
|
|
|
@defmodule[scheme/runtime-config]{
|
|
The @racketmodname[scheme/runtime-config] library is like
|
|
@racketmodname[racket/runtime-config], except that the result of its
|
|
@racketidfont{configure} function is a procedure that sets
|
|
@racket[print-as-expression] to @racket[#f].}
|
|
|
|
@; ----------------------------------------
|
|
|
|
@compat[scheme/runtime-path racket/runtime-path]
|
|
|
|
@; ----------------------------------------
|
|
|
|
@compat-except[scheme/sandbox racket/sandbox]{, except that
|
|
@|sandbox-namespace-specs-id|, @|make-evaluator-id|, and
|
|
@|make-module-evaluator-id| are replaced}
|
|
|
|
@defparam[sandbox-namespace-specs spec (cons/c (-> namespace?)
|
|
(listof module-path?))]{
|
|
|
|
Like @|sandbox-namespace-specs-id| from
|
|
@racketmodname[racket/sandbox], but the default is @racket[(list
|
|
make-base-namespace)] if @racket[gui?] is @racket[#f], @racket[(list
|
|
make-gui-namespace)] if @racket[gui?] is @racket[#t].}
|
|
|
|
@defproc*[([(make-evaluator [language (or/c module-path?
|
|
(list/c 'special symbol?)
|
|
(cons/c 'begin list?))]
|
|
[input-program any/c] ...
|
|
[#:requires requires (listof (or/c module-path? path?))]
|
|
[#:allow-read allow (listof (or/c module-path? path?))])
|
|
(any/c . -> . any)]
|
|
[(make-module-evaluator [module-decl (or/c syntax? pair?)]
|
|
[#:language lang (or/c #f module-path?)]
|
|
[#:allow-read allow (listof (or/c module-path? path?))])
|
|
(any/c . -> . any)])]{
|
|
|
|
Like @|make-evaluator-id| and @|make-module-evaluator-id| from
|
|
@racketmodname[racket/sandbox], but the value of the
|
|
@racket[sandbox-namespace-specs] parameter is installed as the
|
|
value of @|sandbox-namespace-specs-id| from
|
|
@racketmodname[racket/sandbox] before chaining to @|make-evaluator-id|
|
|
and @|make-module-evaluator-id| from @racketmodname[racket/sandbox].}
|
|
|
|
@; ----------------------------------------
|
|
|
|
@compat[scheme/serialize racket/serialize]
|
|
@compat[scheme/set racket/set]
|
|
@compat[scheme/signature racket/signature]
|
|
@compat[scheme/shared racket/shared]
|
|
@compat[scheme/splicing racket/splicing]
|
|
@compat[scheme/string racket/string]
|
|
@compat[scheme/struct-info racket/struct-info]
|
|
@compat[scheme/stxparam racket/stxparam]
|
|
@compat[scheme/stxparam-exptime racket/stxparam-exptime]
|
|
@compat[scheme/surrogate racket/surrogate]
|
|
@compat[scheme/system racket/system]
|
|
@compat[scheme/tcp racket/tcp]
|
|
@; @compat[scheme/trace racket/trace]
|
|
@compat[scheme/trait racket/trait]
|
|
@compat[scheme/udp racket/udp]
|
|
|
|
@compat-except[scheme/unit racket/unit]{, except that @|unit-struct|
|
|
and @|unit-struct/ctc| are @racket[struct~s] and
|
|
@racket[struct~s/ctc] from @racketmodname[mzlib/unit] instead of
|
|
@racket[struct] from @racket[racket/base] and @racket[struct/ctc] from
|
|
@racketmodname[racket/unit]}
|
|
|
|
@compat[scheme/unit-exptime racket/unit-exptime]
|
|
@compat[scheme/unsafe/ops racket/unsafe/ops]
|
|
@compat[scheme/vector racket/vector]
|
|
|
|
@; ----------------------------------------
|
|
|
|
@section[@racketmodname[mred]]
|
|
@defmodule[mred]
|
|
|
|
The @racketmodname[mred] library is like
|
|
@racketmodname[scheme/gui/base], except that it provides variants of
|
|
@racket[make-gui-namespace] and @racket[make-gui-empty-namespace] that
|
|
attach @racketmodname[mred] instead of
|
|
@racketmodname[scheme/gui/base].
|
|
|
|
Both @racketmodname[scheme/gui/base] and
|
|
@racketmodname[racket/gui/base] depend on @racketmodname[mred], so it
|
|
is attached by all variants of @racket[make-gui-empty-namespace].
|
|
|
|
@defmodule*/no-declare[(mred/mred)]
|
|
|
|
The @racketmodname[mred] library actually just re-exports
|
|
@racketmodname[mred/mred], which is an even older name for the
|
|
library.
|
|
|
|
@; ----------------------------------------
|
|
|
|
@include-section["compat.scrbl"]
|