Fixes spelling errors in reference.
This commit is contained in:
David Van Horn
Eli Barzilay
parent
49064bc802
commit
f029117266
|
|
@ -328,7 +328,7 @@ For communication among @tech{places}, the new byte string is allocated in the
|
|||
|
||||
@defproc[(string-utf-8-length [str string?]
|
||||
[start exact-nonnegative-integer? 0]
|
||||
[end exact-nonnegative-integer? (string-lenght str)])
|
||||
[end exact-nonnegative-integer? (string-length str)])
|
||||
exact-nonnegative-integer?]{
|
||||
Returns the length in bytes of the UTF-8 encoding of @racket[str]'s
|
||||
substring from @racket[start] to @racket[end], but without actually
|
||||
|
|
@ -458,7 +458,7 @@ Certain encoding combinations are always available:
|
|||
Windows) is effectively replaced with @racket[(char->integer #\?)].}
|
||||
|
||||
@item{@racket[(bytes-open-converter "platform-UTF-16" "platform-UTF-8")]
|
||||
--- converts UTF-16 (bytes orderd by the current platform's
|
||||
--- converts UTF-16 (bytes ordered by the current platform's
|
||||
endianness) to UTF-8 on @|AllUnix|. On Windows, the input can
|
||||
include UTF-16 code units that are unpaired surrogates, and the
|
||||
corresponding output includes an encoding of each surrogate in a
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ arbitrary procedure through impersonators on the operation's
|
|||
argument---assuming that the operation is available to the creator of
|
||||
the impersonator:
|
||||
|
||||
@operations[@t{a structure-field accesor}
|
||||
@operations[@t{a structure-field accessor}
|
||||
@t{a structure-field mutator}
|
||||
@t{a structure type property accessor}
|
||||
@t{application of a procedure}
|
||||
|
|
|
|||
|
|
@ -5,10 +5,9 @@
|
|||
|
||||
@note-lib[racket/cmdline]
|
||||
|
||||
@defform/subs[#:literals (multi once-each once-any final jelp-labels args
|
||||
help-labels =>)
|
||||
(command-line optional-name-expr optional-argv-expr
|
||||
flag-clause ...
|
||||
@defform/subs[#:literals (multi once-each once-any final args help-labels =>)
|
||||
(command-line optional-name-expr optional-argv-expr
|
||||
flag-clause ...
|
||||
finish-clause)
|
||||
([optional-name-expr code:blank
|
||||
(code:line #:program name-expr)]
|
||||
|
|
@ -19,7 +18,7 @@
|
|||
(code:line #:once-any flag-spec ...)
|
||||
(code:line #:final flag-spec ...)
|
||||
(code:line #:help-labels string ...)]
|
||||
[flag-spec (flags id ... help-spec body ...+)
|
||||
[flag-spec (flags id ... help-spec body ...+)
|
||||
(flags => handler-expr help-expr)]
|
||||
[flags flag-string
|
||||
(flag-string ...+)]
|
||||
|
|
@ -149,7 +148,7 @@ that are not parsed as flags:
|
|||
|
||||
@itemize[
|
||||
|
||||
@item{Supplying no finish clause is the same as suppling
|
||||
@item{Supplying no finish clause is the same as supplying
|
||||
@racket[#:args () (void)].}
|
||||
|
||||
@item{For an @racket[#:args] finish clause, identifiers in
|
||||
|
|
|
|||
|
|
@ -1168,7 +1168,7 @@ produces @racket[#f], no name is printed. Otherwise, it is also formatted as by
|
|||
@racket[display].
|
||||
|
||||
If specified, @racket[source-location-expr] indicates the source location
|
||||
reported by contract violations. The expession must produce a @racket[srcloc]
|
||||
reported by contract violations. The expression must produce a @racket[srcloc]
|
||||
structure, @tech{syntax object}, @racket[#f], or a list or vector in the format
|
||||
accepted by the third argument to @racket[datum->syntax].
|
||||
|
||||
|
|
@ -1294,7 +1294,7 @@ modules. First, one module defines a function, and then that
|
|||
module is required by another. So, far the function itself
|
||||
has to go from the original, providing module to the
|
||||
requiring module. Now, imagine that the providing module
|
||||
invokes the function, suppying it an argument. At this
|
||||
invokes the function, supplying it an argument. At this
|
||||
point, the flow of values reverses. The argument is
|
||||
traveling back from the requiring module to the providing
|
||||
module! And finally, when the function produces a result,
|
||||
|
|
@ -1836,7 +1836,7 @@ are below):
|
|||
or not this module exports anything matching the contract)
|
||||
can be blamed for violating the contract. This comes into play
|
||||
for @racket[->i] contracts, since the contract itself has
|
||||
acceess to values under contract via the dependency.
|
||||
access to values under contract via the dependency.
|
||||
}
|
||||
]
|
||||
|
||||
|
|
|
|||
|
|
@ -144,7 +144,7 @@ The @racket[reset] and @racket[prompt] forms are interchangeable.}
|
|||
|
||||
@deftogether[(
|
||||
@defform[(reset-at prompt-tag-expr expr ...+)]
|
||||
@defform[(shift-at prompt-tag-expr identifer expr ...+)]
|
||||
@defform[(shift-at prompt-tag-expr identifier expr ...+)]
|
||||
)]{
|
||||
|
||||
Like @racket[reset] and @racket[shift], but using the specified prompt
|
||||
|
|
|
|||
|
|
@ -182,7 +182,7 @@ earlier mappings.
|
|||
(dict-set* #hash((a . "apple") (b . "beer")) 'b "banana" 'a "anchor")
|
||||
(dict-set* '() 'a "apple" 'b "beer")
|
||||
(dict-set* '((a . "apple") (b . "beer")) 'b "banana" 'a "anchor")
|
||||
(dict-set* '((a . "apple") (b . "beer")) 'b "banana" 'b "balistic")
|
||||
(dict-set* '((a . "apple") (b . "beer")) 'b "banana" 'b "ballistic")
|
||||
]}
|
||||
|
||||
@defproc[(dict-has-key? [dict dict?] [key any/c])
|
||||
|
|
|
|||
|
|
@ -137,7 +137,7 @@ Most @tech{continuations} expect a particular number of result
|
|||
2))] accepts any number of result @tech{values}, because it ignores
|
||||
the result(s).
|
||||
|
||||
In general, the specification of a syntactic form inidicates the
|
||||
In general, the specification of a syntactic form indicates the
|
||||
number of @tech{values} that it produces and the number that it
|
||||
expects from each of its sub-expression. In addition, some procedures
|
||||
(notably @racket[values]) produce multiple @tech{values}, and some
|
||||
|
|
|
|||
|
|
@ -207,7 +207,7 @@ calls the @tech{extension-load handler} in tail position.}
|
|||
|
||||
@defproc[(load-relative-extension [file path-string?]) any]{
|
||||
|
||||
Like @racket[load-exension], but resolves @racket[file] using
|
||||
Like @racket[load-extension], but resolves @racket[file] using
|
||||
@racket[current-load-relative-directory] like @racket[load-relative].}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -380,7 +380,7 @@ Instances of a structure type with the @racket[prop:input-port] or
|
|||
of being a port. If the structure type has more than one of
|
||||
@racket[prop:evt], @racket[prop:input-port], and
|
||||
@racket[prop:output-port], then the @racket[prop:evt] value (if any)
|
||||
takes precedence for determing the instance's behavior as an event,
|
||||
takes precedence for determining the instance's behavior as an event,
|
||||
and the @racket[prop:input-port] property takes precedence over
|
||||
@racket[prop:output-port] for synchronization.
|
||||
|
||||
|
|
|
|||
|
|
@ -942,7 +942,7 @@ The preference file should contain a list of symbol--value lists
|
|||
written with the default parameter settings. Keys
|
||||
starting with @racket[racket:], @racket[mzscheme:], @racket[mred:],
|
||||
and @racket[plt:] in any letter case are reserved for use by Racket
|
||||
implementers. If the preference file does not contain a list
|
||||
implementors. If the preference file does not contain a list
|
||||
of symbol--value lists, an error is logged via @racket[log-error]
|
||||
and @racket[failure-thunk] is called.
|
||||
|
||||
|
|
|
|||
|
|
@ -104,7 +104,7 @@ performed more efficiently, and terminates when the vector is full or
|
|||
the requested number of iterations have been performed, whichever
|
||||
comes first. If the provided @racket[length-expr] evaluates to a
|
||||
length longer than the number of iterations then the remaining slots
|
||||
of the vector are intialized to the default argument of
|
||||
of the vector are initialized to the default argument of
|
||||
@racket[make-vector].}
|
||||
|
||||
@deftogether[(
|
||||
|
|
|
|||
|
|
@ -315,7 +315,7 @@ In more detail, patterns match as follows:
|
|||
|
||||
@item{@racket[(#,(racketidfont "app") _expr _pat)] --- applies
|
||||
@racket[_expr] to the value to be matched; the result of the
|
||||
application is matched againt @racket[_pat].
|
||||
application is matched against @racket[_pat].
|
||||
|
||||
@examples[
|
||||
#:eval match-eval
|
||||
|
|
|
|||
|
|
@ -227,7 +227,7 @@ this procedure is never called (unless garbage collection is disabled).}
|
|||
|
||||
Returns an estimate of the number of bytes of memory occupied by
|
||||
reachable data from @racket[cust]. This estimate is calculated by the
|
||||
last garbage colection, and can be 0 if none occurred (or if none occurred
|
||||
last garbage collection, and can be 0 if none occurred (or if none occurred
|
||||
since the given custodian was created). The @racket[current-memory-use]
|
||||
function does @italic{not} perform a collection by itself; doing one
|
||||
before the call will generally decrease the result (or increase it from
|
||||
|
|
|
|||
|
|
@ -557,7 +557,7 @@ Returns the natural logarithm of @racket[z]. The result is normally
|
|||
|
||||
|
||||
@; ------------------------------------------------------------------------
|
||||
@subsection{Trignometric Functions}
|
||||
@subsection{Trigonometric Functions}
|
||||
|
||||
@defproc[(sin [z number?]) number?]{
|
||||
|
||||
|
|
|
|||
|
|
@ -184,7 +184,7 @@ mode but with a @litchar{'} prefix; the pair's content is printed with
|
|||
@racket[cdr] is not @tech{quotable}, then pair prints with either
|
||||
@litchar{cons} (when the @racket[cdr] is not a pair), @litchar{list}
|
||||
(when the pair is a list), or @litchar{list*} (otherwise) after the
|
||||
openining @litchar{(}, any @litchar{.} that would otherwise be printed
|
||||
opening @litchar{(}, any @litchar{.} that would otherwise be printed
|
||||
is suppressed, and the pair content is printed at @tech{quoting depth}
|
||||
@racket[0]. In all cases, when @racket[print-as-expression] is
|
||||
@racket[#t] for @racket[print] mode, then the value of
|
||||
|
|
|
|||
|
|
@ -208,7 +208,7 @@ case-sensitive mode.
|
|||
@section-index["numbers" "parsing"]
|
||||
|
||||
A sequence that does not start with a delimiter is parsed as a @tech{number}
|
||||
when it matches the following grammar case-insenstively for
|
||||
when it matches the following grammar case-insensitively for
|
||||
@nonterm{number@sub{10}} (decimal), where @metavar{n} is a
|
||||
meta-meta-variable in the grammar. The resulting number is @tech{interned} in
|
||||
@racket[read-syntax] mode.
|
||||
|
|
@ -349,7 +349,7 @@ elements are themselves in @racket[read-syntax] mode, so that the
|
|||
result is a list or pair of syntax objects that is itself wrapped as a
|
||||
syntax object. If the reader constructs nested pairs because the input
|
||||
included a single delimited @litchar{.}, then only the innermost pair
|
||||
and outtermost pair are wrapped as syntax objects. Whether wrapping a
|
||||
and outermost pair are wrapped as syntax objects. Whether wrapping a
|
||||
pair or list, if the pair or list was formed with @litchar{[} and
|
||||
@litchar{]}, then a @indexed-racket['paren-shape] property is attached
|
||||
to the result with the value @racket[#\[]; if the list or pair was
|
||||
|
|
@ -458,7 +458,7 @@ Within a string sequence, the following escape sequences are
|
|||
|
||||
]
|
||||
|
||||
If the reader encounteres any other use of a backslash in a string
|
||||
If the reader encounters any other use of a backslash in a string
|
||||
constant, the @exnraise[exn:fail:read].
|
||||
|
||||
@guideintro["bytestrings"]{the syntax of byte strings}
|
||||
|
|
@ -499,7 +499,7 @@ encountered before a terminating line, the @exnraise[exn:fail:read].
|
|||
|
||||
@section[#:tag "parse-quote"]{Reading Quotes}
|
||||
|
||||
When the reader enounters @as-index{@litchar{'}}, it recursively
|
||||
When the reader encounters @as-index{@litchar{'}}, it recursively
|
||||
reads one datum and forms a new list containing the @tech{symbol}
|
||||
@racket['quote] and the following datum. This convention is mainly
|
||||
useful for reading Racket code, where @racket['s] can be used as a
|
||||
|
|
|
|||
|
|
@ -153,7 +153,7 @@ syntactic restrictions:
|
|||
|
||||
]
|
||||
|
||||
These contraints are checked syntactically by the following type
|
||||
These constraints are checked syntactically by the following type
|
||||
system. A type [@math{n}, @math{m}] corresponds to an expression that
|
||||
matches between @math{n} and @math{m} characters. In the rule for
|
||||
@litchar{(}@nonterm{Regexp}@litchar{)}, @math{N} means the number such
|
||||
|
|
|
|||
|
|
@ -131,8 +131,8 @@
|
|||
| Sm Symbol, math #ucat
|
||||
| So Symbol, other #ucat
|
||||
| S Union of _Sc_, _Sk_, _Sm_, and _So_ #ucat
|
||||
| Zl Seaprator, line #ucat
|
||||
| Zp Seaparator, paragraph #ucat
|
||||
| Zl Separator, line #ucat
|
||||
| Zp Separator, paragraph #ucat
|
||||
| Zs Separator, space #ucat
|
||||
| Z Union of _Zl_, _Zp_, and _Zs_ #ucat
|
||||
| Cc Other, control #ucat
|
||||
|
|
|
|||
|
|
@ -165,7 +165,7 @@ top-level namespace:
|
|||
The @racket[make-module-evaluator] function is essentially a
|
||||
restriction of @racket[make-evaluator], where the program must be a
|
||||
module, and all imports are part of the program. In some cases it is
|
||||
useful to restrict the program to be a module using a spcific module
|
||||
useful to restrict the program to be a module using a specific module
|
||||
in its language position --- use the optional @racket[lang] argument
|
||||
to specify such a restriction (the default, @racket[#f], means no
|
||||
restriction is enforced). When the program is specified as a path, then
|
||||
|
|
@ -217,7 +217,7 @@ be @racket[load]ed. (The precise permissions needed for
|
|||
moved to @racket[allow-for-require], while other elements are moved to
|
||||
@racket[all-for-load].
|
||||
|
||||
The sandboxed evironment is well isolated, and the evaluator function
|
||||
The sandboxed environment is well isolated, and the evaluator function
|
||||
essentially sends it an expression and waits for a result. This form
|
||||
of communication makes it impossible to have nested (or concurrent)
|
||||
calls to a single evaluator. Usually this is not a problem, but in
|
||||
|
|
@ -227,7 +227,7 @@ sandboxed code, for example:
|
|||
(let ([e (make-evaluator 'racket/base)])
|
||||
(e (,e 1)))
|
||||
]
|
||||
An error will be signalled in such cases.
|
||||
An error will be signaled in such cases.
|
||||
|
||||
Evaluation can also be instrumented to track coverage information when
|
||||
@racket[sandbox-coverage-enabled] is set. Exceptions (both syntax and
|
||||
|
|
@ -387,7 +387,7 @@ which creates an empty port. The following other values are allowed:
|
|||
|
||||
A parameter that determines the initial @racket[current-output-port]
|
||||
setting for a newly created evaluator. It defaults to @racket[#f],
|
||||
which creates a port that discrds all data. The following other
|
||||
which creates a port that discards all data. The following other
|
||||
values are allowed:
|
||||
|
||||
@itemize[
|
||||
|
|
@ -553,7 +553,7 @@ The default value is null, but when an evaluator is created, it is
|
|||
augmented by @racket['read-bytecode] permissions that make it possible
|
||||
to use collection libraries (including
|
||||
@racket[sandbox-override-collection-paths]). See
|
||||
@racket[make-evalautor] for more information.}
|
||||
@racket[make-evaluator] for more information.}
|
||||
|
||||
|
||||
@defparam[sandbox-network-guard proc
|
||||
|
|
@ -563,7 +563,7 @@ to use collection libraries (including
|
|||
(or/c 'server 'client)
|
||||
. -> . any)]{
|
||||
|
||||
A parameter that specifieds a procedure to be used (as is) by the
|
||||
A parameter that specifies a procedure to be used (as is) by the
|
||||
default @racket[sandbox-security-guard]. The default forbids all
|
||||
network connection.}
|
||||
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ On start-up, the top-level environment contains no bindings---not even
|
|||
that start with @racketidfont{#%} are defined, but they are not meant
|
||||
for direct use, and the set of such modules can change. For example,
|
||||
the @indexed-racket['#%kernel] module is eventually used to bootstrap
|
||||
the implemetation of @racketmodname[racket/base].
|
||||
the implementation of @racketmodname[racket/base].
|
||||
|
||||
The first action of Racket or GRacket is to initialize
|
||||
@racket[current-library-collection-paths] to the result of
|
||||
|
|
|
|||
|
|
@ -202,7 +202,7 @@ environment (that is, at phase level 1), optionally extended with
|
|||
(begin
|
||||
(printf "at compile time produces ~s\n"
|
||||
(syntax-local-eval #'expr))
|
||||
#'(printf "at run time produes ~s\n"
|
||||
#'(printf "at run time produces ~s\n"
|
||||
expr))]))
|
||||
(show-me (+ 2 5))
|
||||
(define-for-syntax fruit 'apple)
|
||||
|
|
|
|||
|
|
@ -1207,7 +1207,7 @@ In other words, the previous method requires only a single unique name.}
|
|||
|
||||
Specifies multiple files to be required from a hierarchy of
|
||||
directories or collections. The set of required module paths is computed
|
||||
as the cartesian product of the @racket[subs] groups, where each
|
||||
as the Cartesian product of the @racket[subs] groups, where each
|
||||
@racket[sub-path] is combined with other @racket[sub-path]s in order
|
||||
using a @litchar{/} separator. A @racket[sub-path] as a @racket[subs]
|
||||
is equivalent to @racket[(sub-path)]. All @racket[sub-path]s in a given
|
||||
|
|
|
|||
|
|
@ -590,7 +590,7 @@ propagates imports and exports; the difference is that the connection
|
|||
between @racket[import] and the right-hand side of the link clause is
|
||||
based on the names of elements in signatures, rather than the names of
|
||||
the signatures. That is, a @racket[tagged-sig-spec] on the right-hand
|
||||
side of the link clause need not apppear as a @racket[tagged-sig-spec]
|
||||
side of the link clause need not appear as a @racket[tagged-sig-spec]
|
||||
in the @racket[import] clause, but each of the bindings implied by the
|
||||
linking @racket[tagged-sig-spec] must be implied by some
|
||||
@racket[tagged-sig-spec] in the @racket[import] clause. Similarly,
|
||||
|
|
@ -808,7 +808,7 @@ binding of the corresponding signature.
|
|||
If @racket[unit-identifier] is not bound to static unit information,
|
||||
then the @exnraise[exn:fail:syntax]. In that case, the given
|
||||
@racket[err-syntax] argument is used as the source of the error, where
|
||||
@racket[unit-identifer] is used as the detail source location.}
|
||||
@racket[unit-identifier] is used as the detail source location.}
|
||||
|
||||
|
||||
@defproc[(signature-members [sig-identifier identifier?]
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
|
||||
@defmodule[racket/unsafe/ops]
|
||||
|
||||
All fuctions and forms provided by @racketmodname[racket/base] and
|
||||
All functions and forms provided by @racketmodname[racket/base] and
|
||||
@racketmodname[racket] check their arguments to ensure that the
|
||||
arguments conform to contracts and other constraints. For example,
|
||||
@racket[vector-ref] checks its arguments to ensure that the first
|
||||
|
|
@ -307,6 +307,6 @@ Unsafe field access and update for an instance of a structure
|
|||
type, where the @schemeidfont{struct*} variants can be
|
||||
faster but do not work on @tech{impersonators}.
|
||||
The index @racket[k] must be between @racket[0] (inclusive) and
|
||||
the number of fields in the struture (exclusive). In the case of
|
||||
the number of fields in the structure (exclusive). In the case of
|
||||
@racket[unsafe-struct-set!], the field must be mutable.}
|
||||
|
||||
|
|
|
|||
|
|
@ -230,7 +230,7 @@ in Racket strings. Thus, the path @litchar{\\?\REL\..\\..} as
|
|||
a string must be written @racket["\\\\?\\REL\\..\\\\.."].
|
||||
|
||||
A path that ends with a directory separator syntactically refers to a
|
||||
directory. In addition, a path syntactcially refers to a directory if
|
||||
directory. In addition, a path syntactically refers to a directory if
|
||||
its last element is a same-directory or up-directory indicator (not
|
||||
quoted by a @litchar{\\?\} form), or if it refers to a root.
|
||||
|
||||
|
|
@ -262,7 +262,7 @@ included in the result.
|
|||
For @racket[(build-path _base-path _sub-path ...)], trailing spaces
|
||||
and periods are removed from the last element of @racket[_base-path]
|
||||
and all but the last @racket[_sub-path] (unless the element consists of
|
||||
only spaces and peroids), except for those that start with
|
||||
only spaces and periods), except for those that start with
|
||||
@litchar{\\?\}. If @racket[_base-path] starts @litchar{\\?\},
|
||||
then after each non-@litchar{\\?\REL\} and
|
||||
non-@litchar{\\?\RED\} @racket[_sub-path] is added, all
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user