commit 44f21bb69fe3e7d8d4d68a61550576fa24a3ea8e
parent 10602734eac6a205812eae2dfa208cb01e0cd160
Author: Wolfgang Corcoran-Mathe <wcm@sigwinch.xyz>
Date: Mon, 29 Jan 2024 13:55:59 -0500
Replace non-ASCII chars. in names; replace ellipses.
Diffstat:
1 file changed, 157 insertions(+), 157 deletions(-)
diff --git a/doc/r7rs-small/r7rs-small.texinfo b/doc/r7rs-small/r7rs-small.texinfo
@@ -170,7 +170,7 @@ Feeley, Chris Hanson, Jonathan Rees, and Olin Shivers, for their support and gui
This report is very much a community effort, and we'd like to thank everyone who
provided comments and feedback, including the following people: David Adler, Eli
-Barzilay, Taylan Ulrich Bayırlı/Kammer, Marco Benelli, Pierpaolo Bernardi, Peter Bex, Per
+Barzilay, Taylan Ulrich Bay@dotless{i}rl@dotless{i}/Kammer, Marco Benelli, Pierpaolo Bernardi, Peter Bex, Per
Bothner, John Boyle, Taylor Campbell, Raffael Cavallaro, Ray Dillinger, Biep Durieux,
Sztefan Edwards, Helmut Eller, Justin Ethier, Jay Reynolds Freeman, Tony Garnock-Jones,
Alan Manuel Gloria, Steve Hafner, Sven Hartrumpf, Brian Harvey, Moritz Heidkamp,
@@ -182,13 +182,13 @@ Joseph Wayne Norton, Yuki Okumura, Daichi Oohashi, Jeronimo Pellegrini, Jussi
Piitulainen, Alex Queiroz, Jim Rees, Grant Rettke, Andrew Robbins, Devon Schudy, Bakul
Shah, Robert Smith, Arthur Smyles, Michael Sperber, John David Stone, Jay Sulzberger,
Malcolm Tredinnick, Sam Tobin-Hochstadt, Andre van Tonder, Daniel Villeneuve, Denis
-Washington, Alan Watson, Mark H. Weaver, Göran Weinholt, David A. Wheeler, Andy
-Wingo, James Wise, Jörg F. Wittenberger, Kevin A. Wortman, Sascha Ziemann.
+Washington, Alan Watson, Mark H. Weaver, G@"oran Weinholt, David A. Wheeler, Andy
+Wingo, James Wise, J@"org F. Wittenberger, Kevin A. Wortman, Sascha Ziemann.
In addition we would like to thank all the past editors, and the people who helped them in
turn: Hal Abelson, Norman Adams, David Bartley, Alan Bawden, Michael Blair, Gary
Brooks, George Carrette, Andy Cromarty, Pavel Curtis, Jeff Dalton, Olivier Danvy, Ken
-Dickey, Bruce Duba, Robert Findler, Andy Freeman, Richard Gabriel, Yekta Gürsel, Ken
+Dickey, Bruce Duba, Robert Findler, Andy Freeman, Richard Gabriel, Yekta G@"ursel, Ken
Haase, Robert Halstead, Robert Hieb, Paul Hudak, Morry Katz, Eugene Kohlbecker, Chris
Lindblad, Jacob Matthews, Mark Meyer, Jim Miller, Don Oxley, Jim Philbin, Kent Pitman,
John Ramsdell, Guillermo Rozas, Mike Shaff, Jonathan Shapiro, Guy Steele, Julie Sussman,
@@ -395,11 +395,11 @@ variables, which are written using angle brackets, for example <expression> and
example, <expression> stands for any string of characters which is a syntactically valid
expression. The notation
-<thing1> …
+<thing1> @dots{}
indicates zero or more occurrences of a <thing>, and
-<thing1> <thing2> …
+<thing1> <thing2> @dots{}
indicates one or more occurrences of a <thing>.
@@ -455,30 +455,30 @@ restrictions:
integer
k, exact
non-negative
- k1, … integer
+ k1, @dots{} integer
- kj, …
+ kj, @dots{}
letter alphabetic
character
list, list (see section
6.4)
- list1, …
+ list1, @dots{}
- listj, …
+ listj, @dots{}
n, integer
- n1, …
+ n1, @dots{}
- nj, …
+ nj, @dots{}
obj any object
pair pair
port port
proc procedure
q, rational
number
- q1, …
+ q1, @dots{}
- qj, …
+ qj, @dots{}
start exact
non-negative
integer
@@ -489,19 +489,19 @@ restrictions:
vector vector
x, real number
- x1, …
+ x1, @dots{}
- xj, …
+ xj, @dots{}
y, real number
- y1, …
+ y1, @dots{}
- yj, …
+ yj, @dots{}
z, complex
number
- z1, …
+ z1, @dots{}
- zj, …
+ zj, @dots{}
The names
@@ -1171,7 +1171,7 @@ of a literal expression) using a mutation procedure like set-car! or string-set!
@node Procedure calls
@subsection Procedure calls
-syntax: (<operator> <operand1> …)
+syntax: (<operator> <operand1> @dots{})
A procedure call is written by enclosing in parentheses an expression for the procedure to
be called followed by expressions for the arguments to be passed to it. The operator and
@@ -1246,7 +1246,7 @@ will be returned as the results of the procedure call.
@itemize
@item
-(<variable1> …): The procedure takes a fixed number of arguments; when the
+(<variable1> @dots{}): The procedure takes a fixed number of arguments; when the
procedure is called, the arguments will be stored in fresh locations that are bound to
the corresponding variables.
@@ -1256,7 +1256,7 @@ will be returned as the results of the procedure call.
the list is stored in a fresh location that is bound to <variable>.
@item
-(<variable1> … <variablen> . <variablen+1>): If a space-delimited period precedes the last
+(<variable1> @dots{} <variablen> . <variablen+1>): If a space-delimited period precedes the last
variable, then the procedure takes n or more arguments, where n is the number of
formal arguments before the period (it is an error if there is not at least one). The value
stored in the binding of the last variable will be a newly allocated list of the actual
@@ -1324,8 +1324,8 @@ unspecified.
@node Inclusion
@subsection Inclusion
-syntax: (include <string1> <string2> …)
-syntax: (include-ci <string1> <string2> …)
+syntax: (include <string1> <string2> @dots{})
+syntax: (include-ci <string1> <string2> @dots{})
Semantics: Both include and include-ci take one or more filenames expressed as string
literals, apply an implementation-specific algorithm to find corresponding files, read the
@@ -1360,15 +1360,15 @@ described in this section into the primitive constructs described in the previou
@node Conditionals (cond)
@subsection Conditionals (cond)
-syntax: (cond <clause1> <clause2> …)
+syntax: (cond <clause1> <clause2> @dots{})
auxiliary syntax: else
auxiliary syntax: =>
Syntax: <Clauses> take one of two forms, either
-(<test> <expression1> …)where <test> is any expression, or (<test> => <expression>)The
+(<test> <expression1> @dots{})where <test> is any expression, or (<test> => <expression>)The
last <clause> can be an ``else clause,'' which has the form (else <expression1>
-<expression2> …).
+<expression2> @dots{}).
Semantics: A cond expression is evaluated by evaluating the <test> expressions of
successive <clause>s in order until one of them evaluates to a true value(see section 6.3).
@@ -1400,15 +1400,15 @@ order, and the values of the last one are returned.
@end example
-syntax: (case <key> <clause1> <clause2> …)
+syntax: (case <key> <clause1> <clause2> @dots{})
Syntax: <Key> can be any expression. Each <clause> has the form
-((<datum1> …) <expression1> <expression2> …),where each <datum> is an external
+((<datum1> @dots{}) <expression1> <expression2> @dots{}),where each <datum> is an external
representation of some object. It is an error if any of the <datum>s are the same
-anywhere in the expression. Alternatively, a <clause> can be of the form ((<datum1> …) =>
+anywhere in the expression. Alternatively, a <clause> can be of the form ((<datum1> @dots{}) =>
<expression>)The last <clause> can be an ``else clause,'' which has one of the forms (else
-<expression1> <expression2> …)
+<expression1> <expression2> @dots{})
or (else => <expression>).
Semantics: A case expression is evaluated as follows. <Key> is evaluated and its result is
@@ -1441,7 +1441,7 @@ procedure are returned by the case expression.
@end example
-syntax: (and <test1> …)
+syntax: (and <test1> @dots{})
Semantics: The <test> expressions are evaluated from left to right, and if any expression
evaluates to #f (see section 6.3), then #f is returned. Any remaining expressions are not
@@ -1457,7 +1457,7 @@ are returned. If there are no expressions, then #t is returned.
@end example
-syntax: (or <test1> …)
+syntax: (or <test1> @dots{})
Semantics: The <test> expressions are evaluated from left to right, and the value of the
first expression that evaluates to a true value (see section 6.3) is returned. Any remaining
@@ -1474,7 +1474,7 @@ expressions, then #f is returned.
@end example
-syntax: (when <test> <expression1> <expression2> …)
+syntax: (when <test> <expression1> <expression2> @dots{})
Syntax: The <test> is an expression.
@@ -1490,7 +1490,7 @@ evaluated in order. The result of the when expression is unspecified.
@end example
-syntax: (unless <test> <expression1> <expression2> …)
+syntax: (unless <test> <expression1> <expression2> @dots{})
Syntax: The <test> is an expression.
@@ -1506,16 +1506,16 @@ order. The result of the unless expression is unspecified.
@end example
-syntax: (cond-expand <ce-clause1> <ce-clause2> …)
+syntax: (cond-expand <ce-clause1> <ce-clause2> @dots{})
Syntax: The cond-expand expression type provides a way to statically expand different
expressions depending on the implementation. A <ce-clause> takes the following form:
-(<feature requirement> <expression> …)
+(<feature requirement> <expression> @dots{})
The last clause can be an ``else clause,'' which has the form
-(else <expression> …)
+(else <expression> @dots{})
A <feature requirement> takes one of the following forms:
@@ -1527,10 +1527,10 @@ A <feature requirement> takes one of the following forms:
(library <library name>)
@item
-(and <feature requirement> …)
+(and <feature requirement> @dots{})
@item
-(or <feature requirement> …)
+(or <feature requirement> @dots{})
@item
(not <feature requirement>)
@@ -1571,7 +1571,7 @@ syntax: (let <bindings> <body>)
Syntax: <Bindings> has the form
-((<variable1> <init1>) …),where each <init> is an expression, and <body> is a sequence of
+((<variable1> <init1>) @dots{}),where each <init> is an expression, and <body> is a sequence of
zero or more definitions followed by a sequence of one or more expressions as described
in section 4.1.4. It is an error for a <variable> to appear more than once in the list of
variables being bound.
@@ -1597,7 +1597,7 @@ syntax: (let* <bindings> <body>)
Syntax: <Bindings> has the form
-((<variable1> <init1>) …),and <body> is a sequence of zero or more definitions followed by
+((<variable1> <init1>) @dots{}),and <body> is a sequence of zero or more definitions followed by
one or more expressions as described in section 4.1.4.
Semantics: The let* binding construct is similar to let, but the bindings are performed
@@ -1619,7 +1619,7 @@ syntax: (letrec <bindings> <body>)
Syntax: <Bindings> has the form
-((<variable1> <init1>) …),and <body> is a sequence of zero or more definitions followed by
+((<variable1> <init1>) @dots{}),and <body> is a sequence of zero or more definitions followed by
one or more expressions as described in section 4.1.4. It is an error for a <variable> to
appear more than once in the list of variables being bound.
@@ -1657,7 +1657,7 @@ syntax: (letrec* <bindings> <body>)
Syntax: <Bindings> has the form
-((<variable1> <init1>) …),and <body>is a sequence of zero or more definitions followed by
+((<variable1> <init1>) @dots{}),and <body>is a sequence of zero or more definitions followed by
one or more expressions as described in section 4.1.4. It is an error for a <variable> to
appear more than once in the list of variables being bound.
@@ -1704,7 +1704,7 @@ syntax: (let-values <mv binding spec> <body>)
Syntax: <Mv binding spec> has the form
-((<formals1> <init1>) …), where each <init> is an expression, and <body> is zero or more
+((<formals1> <init1>) @dots{}), where each <init> is an expression, and <body> is zero or more
definitions followed by a sequence of one or more expressions as described in section
4.1.4. It is an error for a variable to appear more than once in the set of <formals>.
@@ -1730,7 +1730,7 @@ syntax: (let*-values <mv binding spec> <body>)
Syntax: <Mv binding spec> has the form
-((<formals> <init>) …),and <body> is a sequence of zero or more definitions followed by
+((<formals> <init>) @dots{}),and <body> is a sequence of zero or more definitions followed by
one or more expressions as described in section 4.1.4. In each <formals>, it is an error if
any variable appears more than once.
@@ -1755,7 +1755,7 @@ and so on.
Both of Scheme's sequencing constructs are named begin, but the two have slightly
different forms and uses:
-syntax: (begin <expression or definition> …)
+syntax: (begin <expression or definition> @dots{})
This form of begin can appear as part of a <body>, or at the outermost level of a
<program>, or at the REPL, or directly nested in a begin that is itself of this form. It causes
@@ -1766,7 +1766,7 @@ construct were not present.
need to generate multiple definitions and splice them into the context in which they
are expanded.
-syntax: (begin <expression1> <expression2> …)
+syntax: (begin <expression1> <expression2> @dots{})
This form of begin can be used as an ordinary expression. The <expression>s are
evaluated sequentially from left to right, and the values of the last <expression> are
@@ -1792,9 +1792,9 @@ Note that there is a third form of begin used as a library declaration: see sect
@subsection Iteration
syntax: (do ((<variable1> <init1> <step1>)
-…)
-(<test> <expression> …)
-<command> …)
+@dots{})
+(<test> <expression> @dots{})
+<command> @dots{})
Syntax: All of <init>, <step>, <test>, and <command> are expressions.
@@ -2042,7 +2042,7 @@ parameterize, which is described below.
The effect of passing arguments to a parameter object is implementation-dependent.
-syntax: (parameterize ((<param1> <value1>) …)
+syntax: (parameterize ((<param1> <value1>) @dots{})
<body>)
Syntax: Both <param1> and <value1> are expressions.
@@ -2099,7 +2099,7 @@ without the need to pass the value to every procedure in the call chain explicit
@subsection Exception handling
syntax: (guard (<variable>
- <cond clause1> <cond clause2> …)
+ <cond clause1> <cond clause2> @dots{})
<body>)
Syntax: Each <cond clause> is as in the specification of cond.
@@ -2235,7 +2235,7 @@ positions within a <qq template> otherwise than as described above.
@node Case-lambda
@subsection Case-lambda
-case-lambda library syntax: (case-lambda <clause> …)
+case-lambda library syntax: (case-lambda <clause> @dots{})
Syntax: Each <clause> is of the form (<formals> <body>), where <formals> and <body>
have the same syntax as in a lambda expression.
@@ -2323,7 +2323,7 @@ syntax: (let-syntax <bindings> <body>)
Syntax: <Bindings> has the form
-((<keyword> <transformer spec>) …)Each <keyword> is an identifier, each <transformer
+((<keyword> <transformer spec>) @dots{})Each <keyword> is an identifier, each <transformer
spec> is an instance of syntax-rules, and <body> is a sequence of zero or more
definitions followed by one or more expressions. It is an error for a <keyword> to
appear more than once in the list of keywords being bound.
@@ -2390,12 +2390,12 @@ expression.
A <transformer spec> has one of the following forms:
-syntax: (syntax-rules (<pattern literal> …)
- <syntax rule> …)
-syntax: (syntax-rules <ellipsis> (<pattern literal> …)
- <syntax rule> …)
+syntax: (syntax-rules (<pattern literal> @dots{})
+ <syntax rule> @dots{})
+syntax: (syntax-rules <ellipsis> (<pattern literal> @dots{})
+ <syntax rule> @dots{})
auxiliary syntax: _
-auxiliary syntax: …
+auxiliary syntax: @dots{}
Syntax: It is an error if any of the <pattern literal>s, or the <ellipsis> in the second form, is
not an identifier. It is also an error if <syntax rule> is not of the form
@@ -2405,17 +2405,17 @@ element is an identifier.
A <pattern> is either an identifier, a constant, or one of the following
-(<pattern> …)
-(<pattern> <pattern> … . <pattern>)
-(<pattern> … <pattern> <ellipsis> <pattern> …)
-(<pattern> … <pattern> <ellipsis> <pattern> …
+(<pattern> @dots{})
+(<pattern> <pattern> @dots{} . <pattern>)
+(<pattern> @dots{} <pattern> <ellipsis> <pattern> @dots{})
+(<pattern> @dots{} <pattern> <ellipsis> <pattern> @dots{}
. <pattern>)
-#(<pattern> …)
-#(<pattern> … <pattern> <ellipsis> <pattern> …)and a <template> is either an identifier, a
-constant, or one of the following (<element> …)
-(<element> <element> … . <template>)
+#(<pattern> @dots{})
+#(<pattern> @dots{} <pattern> <ellipsis> <pattern> @dots{})and a <template> is either an identifier, a
+constant, or one of the following (<element> @dots{})
+(<element> <element> @dots{} . <template>)
(<ellipsis> <template>)
-#(<element> …)where an <element> is a <template> optionally followed by an <ellipsis>.
+#(<element> @dots{})where an <element> is a <template> optionally followed by an <ellipsis>.
An <ellipsis> is the identifier specified in the second form of syntax-rules, or the default
identifier ... (three consecutive periods) otherwise.
@@ -2441,7 +2441,7 @@ cannot be used to refer to those elements. If an underscore appears in the <patt
literal>s list, then that takes precedence and underscores in the <pattern> match as
literals. Multiple underscores can appear in a <pattern>.
-Identifiers that appear in (<pattern literal> …) are interpreted as literal identifiers to be
+Identifiers that appear in (<pattern literal> @dots{}) are interpreted as literal identifiers to be
matched against corresponding elements of the input. An element in the input matches
a literal identifier if and only if it is an identifier and either both its occurrence in the
macro expression and its occurrence in the macro definition have the same lexical
@@ -2458,25 +2458,25 @@ More formally, an input expression E matches a pattern P if and only if:
* P is a literal identifier and E is an identifier with the same binding; or
-* P is a list (P1 … Pn) and E is a list of n elements that match P1 through Pn, respectively;
+* P is a list (P1 @dots{} Pn) and E is a list of n elements that match P1 through Pn, respectively;
or
-* P is an improper list (P1P2 … Pn . Pn+1) and E is a list or improper list of n or more
+* P is an improper list (P1P2 @dots{} Pn . Pn+1) and E is a list or improper list of n or more
elements that match P1 through Pn, respectively, and whose nth tail matches Pn+1; or
-* P is of the form (P1 … PkPe <ellipsis> Pm+1 … Pn) where E is a proper list of n elements,
+* P is of the form (P1 @dots{} PkPe <ellipsis> Pm+1 @dots{} Pn) where E is a proper list of n elements,
the first k of which match P1 through Pk, respectively, whose next m−k elements each
match Pe, whose remaining n−m elements match Pm+1 through Pn; or
-* P is of the form (P1 … PkPe <ellipsis> Pm+1 … Pn . Px) where E is a list or improper list of n
+* P is of the form (P1 @dots{} PkPe <ellipsis> Pm+1 @dots{} Pn . Px) where E is a list or improper list of n
elements, the first k of which match P1 through Pk, whose next m−k elements each
match Pe, whose remaining n−m elements match Pm+1 through Pn, and whose nth and
final cdr matches Px; or
-* P is a vector of the form #(P1 … Pn) and E is a vector of n elements that match P1
+* P is a vector of the form #(P1 @dots{} Pn) and E is a vector of n elements that match P1
through Pn; or
-* P is of the form #(P1 … PkPe <ellipsis> Pm+1 …Pn) where E is a vector of n elements the
+* P is of the form #(P1 @dots{} PkPe <ellipsis> Pm+1 @dots{}Pn) where E is a vector of n elements the
first k of which match P1 through Pk, whose next m−k elements each match Pe, and
whose remaining n−m elements match Pm+1 through Pn; or
@@ -2557,7 +2557,7 @@ which would result in an invalid procedure call.
@node Signaling errors in macro transformers
@subsection Signaling errors in macro transformers
-syntax: (syntax-error <message> <args> …)
+syntax: (syntax-error <message> <args> @dots{})
syntax-error behaves similarly to error (6.11) except that implementations with an
expansion pass separate from evaluation should signal an error as soon as syntax-error
@@ -2607,9 +2607,9 @@ explained in this chapter. They are valid in some, but not all, contexts where e
are allowed, specifically at the outermost level of a <program> and at the beginning of a
<body>.
-At the outermost level of a program, (begin <expression or definition1> …) is equivalent to
+At the outermost level of a program, (begin <expression or definition1> @dots{}) is equivalent to
the sequence of expressions and definitions in the begin. Similarly, in a <body>, (begin
-<definition1> …) is equivalent to the sequence <definition1> …. Macros can expand into
+<definition1> @dots{}) is equivalent to the sequence <definition1> @dots{}. Macros can expand into
such begin forms. For the formal definition, see 4.2.3.
Import declarations and definitions cause bindings to be created in the global
@@ -2631,21 +2631,21 @@ from the name of a library to its location in the file system.
An import declaration takes the following form:
-(import <import-set> …)
+(import <import-set> @dots{})
An import declaration provides a way to import identifiers exported by a library. Each
<import set> names a set of bindings from a library and possibly specifies local names for
the imported bindings. It takes one of the following forms:
* <library name>
-* (only <import set> <identifier> …)
+* (only <import set> <identifier> @dots{})
-* (except <import set> <identifier> …)
+* (except <import set> <identifier> @dots{})
* (prefix <import set> <identifier>)
* (rename <import set>
- (<identifier1> <identifier2>) …)
+ (<identifier1> <identifier2>) @dots{})
In the first form, all of the identifiers in the named library's export clauses are imported
with the same names (or the exported names if exported with rename). The additional
@@ -2771,7 +2771,7 @@ any of the definitions that follow it in <body>.
It is an error to define the same identifier more than once in the same <body>.
-Wherever an internal definition can occur, (begin <definition1> …) is equivalent to the
+Wherever an internal definition can occur, (begin <definition1> @dots{}) is equivalent to the
sequence of definitions that form the body of the begin.
@node Multiple-value definitions
@@ -2869,11 +2869,11 @@ holds a single location. A predicate, a constructor, and field accessors and mut
defined for each record type.
syntax: (define-record-type <name>
- <constructor> <pred> <field> …)
+ <constructor> <pred> <field> @dots{})
Syntax: <name> and <pred> are identifiers. The <constructor> is of the form
-(<constructor name> <field name> …)and each <field> is either of the form (<field name>
+(<constructor name> <field name> @dots{})and each <field> is either of the form (<field name>
<accessor name>)or of the form (<field name> <accessor name> <modifier name>) It is an
error for the same identifier to occur more than once as a field name. It is also an error
for the same identifier to occur more than once as an accessor or mutator name.
@@ -2890,7 +2890,7 @@ An instance of define-record-type is equivalent to the following definitions:
extensions.
* <constructor name> is bound to a procedure that takes as many arguments as there
- are <field name>s in the (<constructor name> …) subexpression and returns a new
+ are <field name>s in the (<constructor name> @dots{}) subexpression and returns a new
record of type <name>. Fields whose names are listed with <constructor name> have
the corresponding argument as their initial value. The initial values of all other fields are
unspecified. It is an error for a field name to appear in <constructor> but not as a <field
@@ -2953,7 +2953,7 @@ semantics for libraries.
A library definition takes the following form:
(define-library <library name>
- <library declaration> …)
+ <library declaration> @dots{})
<library name> is a list whose members are identifiers and exact non-negative integers. It
is used to identify the library uniquely when importing from other programs or libraries.
Libraries whose first identifier is scheme are reserved for use by this report and future
@@ -2964,19 +2964,19 @@ control characters after escapes are expanded.
A <library declaration> is any of:
-* (export <export spec> …)
+* (export <export spec> @dots{})
-* (import <import set> …)
+* (import <import set> @dots{})
-* (begin <command or definition> …)
+* (begin <command or definition> @dots{})
-* (include <filename1> <filename2> …)
+* (include <filename1> <filename2> @dots{})
-* (include-ci <filename1> <filename2> …)
+* (include-ci <filename1> <filename2> @dots{})
-* (include-library-declarations <filename1> <filename2> …)
+* (include-library-declarations <filename1> <filename2> @dots{})
-* (cond-expand <ce-clause1> <ce-clause2> …)
+* (cond-expand <ce-clause1> <ce-clause2> @dots{})
An export declaration specifies a list of identifiers which can be made visible to other
libraries or programs. An <export spec> takes one of the following forms:
@@ -3897,19 +3897,19 @@ imaginary parts or both are +nan.0. Otherwise it returns #f.
@end example
-procedure: (= z1 z2 z3 …)
+procedure: (= z1 z2 z3 @dots{})
-procedure: (< x1 x2 x3 …)
+procedure: (< x1 x2 x3 @dots{})
-procedure: (> x1 x2 x3 …)
+procedure: (> x1 x2 x3 @dots{})
-procedure: (<= x1 x2 x3 …)
+procedure: (<= x1 x2 x3 @dots{})
-procedure: (>= x1 x2 x3 …)
+procedure: (>= x1 x2 x3 @dots{})
These procedures return #t if their arguments are (respectively): equal, monotonically
@@ -3950,10 +3950,10 @@ procedure: (even? n)
These numerical predicates test a number for a particular property, returning #t or #f.
See note above.
-procedure: (max x1 x2 …)
+procedure: (max x1 x2 @dots{})
-procedure: (min x1 x2 …)
+procedure: (min x1 x2 @dots{})
These procedures return the maximum or minimum of their arguments.
@@ -3972,10 +3972,10 @@ Note: If any argument is inexact, then the result will also be inexact (unless t
represented as an inexact number without loss of accuracy, then the procedure may
report a violation of an implementation restriction.
-procedure: (+ z1 …)
+procedure: (+ z1 @dots{})
-procedure: (* z1 …)
+procedure: (* z1 @dots{})
These procedures return the sum or product of their arguments.
@@ -3993,13 +3993,13 @@ These procedures return the sum or product of their arguments.
procedure: (- z)
-procedure: (- z1 z2 …)
+procedure: (- z1 z2 @dots{})
procedure: (/ z)
-procedure: (/ z1 z2 …)
+procedure: (/ z1 z2 @dots{})
With two or more arguments, these procedures return the difference or quotient of their
@@ -4173,10 +4173,10 @@ truncate-remainder, respectively, and modulo is equivalent to floor-remainder.
Note: These procedures are provided for backward compatibility with earlier
versions of this report.
-procedure: (gcd n1 …)
+procedure: (gcd n1 @dots{})
-procedure: (lcm n1 …)
+procedure: (lcm n1 @dots{})
These procedures return the greatest common divisor or least common multiple of their
@@ -4677,7 +4677,7 @@ obj is either #t or #f and returns #f otherwise.
@end example
-procedure: (boolean=? boolean1 boolean2 boolean3 …)
+procedure: (boolean=? boolean1 boolean2 boolean3 @dots{})
Returns #t if all the arguments are #t or all are #f.
@@ -4915,7 +4915,7 @@ fill. Otherwise the initial contents of each element is unspecified.
@end example
-procedure: (list obj …)
+procedure: (list obj @dots{})
Returns a newly allocated list of its arguments.
@@ -4939,7 +4939,7 @@ Returns the length of @var{list}.
@end example
-procedure: (append @var{list} …)
+procedure: (append @var{list} @dots{})
The last argument, if there is one, can be of any type.
@@ -5215,7 +5215,7 @@ obj is a symbol, otherwise returns #f.
@end example
-procedure: (symbol=? symbol1 symbol2 symbol3 …)
+procedure: (symbol=? symbol1 symbol2 symbol3 @dots{})
Returns #t if all the arguments all have the same names in the sense of string=?.
@@ -5343,19 +5343,19 @@ Returns #t if
obj is a character, otherwise returns #f.
-procedure: (char=? char1 char2 char3 …)
+procedure: (char=? char1 char2 char3 @dots{})
-procedure: (char<? char1 char2 char3 …)
+procedure: (char<? char1 char2 char3 @dots{})
-procedure: (char>? char1 char2 char3 …)
+procedure: (char>? char1 char2 char3 @dots{})
-procedure: (char<=? char1 char2 char3 …)
+procedure: (char<=? char1 char2 char3 @dots{})
-procedure: (char>=? char1 char2 char3 …)
+procedure: (char>=? char1 char2 char3 @dots{})
These procedures return #t if the results of passing their arguments to char->integer
@@ -5364,19 +5364,19 @@ monotonically non-decreasing, or monotonically non-increasing.
These predicates are required to be transitive.
-char library procedure: (char-ci=? char1 char2 char3 …)
+char library procedure: (char-ci=? char1 char2 char3 @dots{})
-char library procedure: (char-ci<? char1 char2 char3 …)
+char library procedure: (char-ci<? char1 char2 char3 @dots{})
-char library procedure: (char-ci>? char1 char2 char3 …)
+char library procedure: (char-ci>? char1 char2 char3 @dots{})
-char library procedure: (char-ci<=? char1 char2 char3 …)
+char library procedure: (char-ci<=? char1 char2 char3 @dots{})
-char library procedure: (char-ci>=? char1 char2 char3 …)
+char library procedure: (char-ci>=? char1 char2 char3 @dots{})
These procedures are similar to char=? et cetera, but they treat upper case and lower
@@ -5531,7 +5531,7 @@ char is given, then all the characters of the string are initialized to
char, otherwise the contents of the string are unspecified.
-procedure: (string char …)
+procedure: (string char @dots{})
Returns a newly allocated string composed of the arguments. It is analogous to list.
@@ -5586,41 +5586,41 @@ string. There is no requirement for this procedure to execute in constant time.
@end example
-procedure: (string=? string1 string2 string3 …)
+procedure: (string=? string1 string2 string3 @dots{})
Returns #t if all the strings are the same length and contain exactly the same characters
in the same positions, otherwise returns #f.
-char library procedure: (string-ci=? string1 string2 string3 …)
+char library procedure: (string-ci=? string1 string2 string3 @dots{})
Returns #t if, after case-folding, all the strings are the same length and contain the same
characters in the same positions, otherwise returns #f. Specifically, these procedures
behave as if string-foldcase were applied to their arguments before comparing them.
-procedure: (string<? string1 string2 string3 …)
+procedure: (string<? string1 string2 string3 @dots{})
-char library procedure: (string-ci<? string1 string2 string3 …)
+char library procedure: (string-ci<? string1 string2 string3 @dots{})
-procedure: (string>? string1 string2 string3 …)
+procedure: (string>? string1 string2 string3 @dots{})
-char library procedure: (string-ci>? string1 string2 string3 …)
+char library procedure: (string-ci>? string1 string2 string3 @dots{})
-procedure: (string<=? string1 string2 string3 …)
+procedure: (string<=? string1 string2 string3 @dots{})
-char library procedure: (string-ci<=? string1 string2 string3 …)
+char library procedure: (string-ci<=? string1 string2 string3 @dots{})
-procedure: (string>=? string1 string2 string3 …)
+procedure: (string>=? string1 string2 string3 @dots{})
-char library procedure: (string-ci>=? string1 string2 string3 …)
+char library procedure: (string-ci>=? string1 string2 string3 @dots{})
These procedures return #t if their arguments are (respectively): monotonically
@@ -5670,7 +5670,7 @@ start and ending with index
end. This is equivalent to calling string-copy with the same arguments, but is provided
for backward compatibility and stylistic flexibility.
-procedure: (string-append string …)
+procedure: (string-append string @dots{})
Returns a newly allocated string whose characters are the concatenation of the
@@ -5783,7 +5783,7 @@ of the vector.
Vectors are written using the notation #(
-obj …). For example, a vector of length 3 containing the number zero in element 0, the
+obj @dots{}). For example, a vector of length 3 containing the number zero in element 0, the
list (2 2 2 2) in element 1, and the string "Anna" in element 2 can be written as follows:
#(0 (2 2 2 2) "Anna") Vector constants are self-evaluating, so they do not need to be
@@ -5804,7 +5804,7 @@ k elements. If a second argument is given, then each element is initialized to
fill. Otherwise the initial contents of each element is unspecified.
-procedure: (vector obj …)
+procedure: (vector obj @dots{})
Returns a newly allocated vector whose elements contain the given arguments. It is
analogous to list.
@@ -6012,7 +6012,7 @@ b ⟹ #(10 1 2 40 50)
@end example
-procedure: (vector-append vector …)
+procedure: (vector-append vector @dots{})
Returns a newly allocated vector whose elements are the concatenation of the elements
@@ -6062,7 +6062,7 @@ starting at index zero as with vectors.
Bytevectors are written using the notation #u8(
-byte …). For example, a bytevector of length 3 containing the byte 0 in element 0, the byte
+byte @dots{}). For example, a bytevector of length 3 containing the byte 0 in element 0, the byte
10 in element 1, and the byte 5 in element 2 can be written as follows:
#u8(0 10 5) Bytevector constants are self-evaluating, so they do not need to be quoted in
@@ -6091,7 +6091,7 @@ byte, otherwise the contents of each element are unspecified.
@end example
-procedure: (bytevector byte …)
+procedure: (bytevector byte @dots{})
Returns a newly allocated bytevector containing its arguments.
@@ -6220,7 +6220,7 @@ b ⟹ #u8(10 1 2 40 50)
Note: This procedure appears in R6RS, but places the source before the destination,
contrary to other such procedures in Scheme.
-procedure: (bytevector-append bytevector …)
+procedure: (bytevector-append bytevector @dots{})
Returns a newly allocated bytevector whose elements are the concatenation of the
@@ -6291,12 +6291,12 @@ obj is a procedure, otherwise returns #f.
@end example
-procedure: (apply proc arg1 … args)
+procedure: (apply proc arg1 @dots{} args)
The apply procedure calls
-proc with the elements of the list @code{(append (list arg1 …) args)} as the actual arguments.
+proc with the elements of the list @code{(append (list arg1 @dots{}) args)} as the actual arguments.
@example
@@ -6311,7 +6311,7 @@ proc with the elements of the list @code{(append (list arg1 …) args)} as the a
@end example
-procedure: (map proc list1 list2 …)
+procedure: (map proc list1 list2 @dots{})
It is an error if
@@ -6357,7 +6357,7 @@ or (2 1)
@end example
-procedure: (string-map proc string1 string2 …)
+procedure: (string-map proc string1 string2 @dots{})
It is an error if
@@ -6400,7 +6400,7 @@ earlier returns are not mutated.
@end example
-procedure: (vector-map proc vector1 vector2 …)
+procedure: (vector-map proc vector1 vector2 @dots{})
It is an error if
@@ -6444,7 +6444,7 @@ or #(2 1)
@end example
-procedure: (for-each proc list1 list2 …)
+procedure: (for-each proc list1 list2 @dots{})
It is an error if
@@ -6480,7 +6480,7 @@ proc to mutate any of the lists.
@end example
-procedure: (string-for-each proc string1 string2 …)
+procedure: (string-for-each proc string1 string2 @dots{})
It is an error if
@@ -6513,7 +6513,7 @@ proc to mutate any of the strings.
@end example
-procedure: (vector-for-each proc vector1 vector2 …)
+procedure: (vector-for-each proc vector1 vector2 @dots{})
It is an error if
@@ -6635,7 +6635,7 @@ Rationale: A common use of call-with-current-continuation is for structured,
call-with-current-continuation procedure allows Scheme programmers to do that
by creating a procedure that acts just like the current continuation.
-procedure: (values obj …)
+procedure: (values obj @dots{})
Delivers all of its arguments to its continuation. The values procedure might be defined
as follows:
@@ -6860,7 +6860,7 @@ the values it returns become the values returned by the call to raise-continuabl
@end example
-procedure: (error message obj …)
+procedure: (error message obj @dots{})
Message should be a string.
@@ -6915,7 +6915,7 @@ output port on a file, respectively. Otherwise, it returns #f.
@node Environments and evaluation
@section Environments and evaluation
-eval library procedure: (environment list1 …)
+eval library procedure: (environment list1 @dots{})
This procedure returns a specifier for the environment that results by starting with an
@@ -7979,7 +7979,7 @@ them have been redefined or shadowed.
The following grammar for quasiquote expressions is not context-free. It is presented as
a recipe for generating an infinite number of production rules. Imagine a copy of the
-following rules for D = 1, 2, 3, …, where D is the nesting depth.
+following rules for D = 1, 2, 3, @dots{}, where D is the nesting depth.
<quasiquotation> ⟶<quasiquotation 1>
<qq template 0> ⟶<expression>
@@ -8099,7 +8099,7 @@ then the meaning of P is
calE [ [ ((lambda (I*) ] ]
P')
<undefined>
- …)
+ @dots{})
where I* is the sequence of variables defined in P, P′ is the sequence of expressions
obtained by replacing every definition in P by an assignment, <undefined> is an
@@ -9530,13 +9530,13 @@ irc.freenode.net and on the Usenet discussion group comp.lang.scheme.
The procedure integrate-system integrates the system
- yk⁄ = fk(y1, y2, …, yn), k = 1,
- …, n
+ yk⁄ = fk(y1, y2, @dots{}, yn), k = 1,
+ @dots{}, n
of differential equations with the method of Runge-Kutta.
The parameter system-derivative is a function that takes a system state (a vector of values
-for the state variables y1, …, yn) and produces a system derivative (the values y1⁄, …, yn⁄). The
+for the state variables y1, @dots{}, yn) and produces a system derivative (the values y1⁄, @dots{}, yn⁄). The
parameter initial-state provides an initial system state, and h is an initial guess for the
length of the integration step.
