commit 06def98d745a1722550d0e43c854b194d2eb3fb6
parent 67c68cee073c12eebe2263aa4ec557189384ab67
Author: Wolfgang Corcoran-Mathe <wcm@sigwinch.xyz>
Date: Sun, 4 Feb 2024 14:08:36 -0500
Characters: Texify.
Diffstat:
1 file changed, 85 insertions(+), 68 deletions(-)
diff --git a/doc/r7rs-small/procedures/characters.texinfo b/doc/r7rs-small/procedures/characters.texinfo
@@ -8,79 +8,82 @@ Unicode characters they see fit, and may also support non-Unicode characters as
Except as otherwise specified, the result of applying any of the following procedures to a
non-Unicode character is implementation-dependent.
-Characters are written using the notation #\@svar{character} or #\@svar{character name} or
-#\x@svar{hex scalar value}.
+Characters are written using the notation @code{#\}@svar{character} or @code{#\}@svar{character name} or
+@code{#\x}@svar{hex scalar value}.
The following character names must be supported by all implementations with the given
values. Implementations may add other names provided they cannot be interpreted as
-hex scalar values preceded by x.
+hex scalar values preceded by @code{x}.
@lisp
-#\alarm ; U+0007
-#\backspace ; U+0008
-#\delete ; U+007F
-#\escape ; U+001B
-#\newline ; the linefeed character, U+000A
-#\null ; the null character, U+0000
-#\return ; the return character, U+000D
-#\space ; the preferred way to write a space
-#\tab ; the tab character, U+0009
+#\alarm @r{; U+0007}
+#\backspace @r{; U+0008}
+#\delete @r{; U+007F}
+#\escape @r{; U+001B}
+#\newline @r{; the linefeed character, U+000A}
+#\null @r{; the null character, U+0000}
+#\return @r{; the return character, U+000D}
+#\space @r{; the preferred way to write a space}
+#\tab @r{; the tab character, U+0009}
@end lisp
Here are some additional examples:
@lisp
-#\a ; lower case letter
-#\A ; upper case letter
-#\( ; left parenthesis
-#\ ; the space character
-#\x03BB ; @theultimate{} (if character is supported)
-#\iota ; @greekiota{} (if character and name are supported)
+#\a @r{; lower case letter}
+#\A @r{; upper case letter}
+#\( @r{; left parenthesis}
+#\ @r{; the space character}
+#\x03BB @r{; @theultimate{} (if character is supported)}
+#\iota @r{; @greekiota{} (if character and name are supported)}
@end lisp
-Case is significant in #\@svar{character}, and in #\⟨character name⟩, but not in #\x<hex scalar
-value>. If @svar{character} in #\@svar{character} is alphabetic, then any character immediately
+Case is significant in @code{#\}@svar{character}, and in @code{#\}⟨character name⟩, but not in
+@code{#\x}@svar{hex scalar value}. If @svar{character} in @code{#\}@svar{character} is alphabetic, then any character immediately
following @svar{character} cannot be one that can appear in an identifier. This rule resolves
-the ambiguous case where, for example, the sequence of characters ``#\space'' could be
+the ambiguous case where, for example, the sequence of characters @samp{#\space} could be
taken to be either a representation of the space character or a representation of the
-character ``#\s'' followed by a representation of the symbol ``pace.''
+character @code{#\s} followed by a representation of the symbol @code{pace}.
-Characters written in the #\ notation are self-evaluating. That is, they do not have to be
-quoted in programs. Some of the procedures that operate on characters ignore the
+Characters written in the @code{#\} notation are self-evaluating. That is, they do not have to be
+quoted in programs.
+
+Some of the procedures that operate on characters ignore the
difference between upper case and lower case. The procedures that ignore case have
-``-ci'' (for ``case insensitive'') embedded in their names.
+@samp{-ci} (for ``case insensitive'') embedded in their names.
@deffn procedure char? obj
-Returns #t if
+Returns @code{#t} if @var{obj} is a character, otherwise returns @code{#f}.
-obj is a character, otherwise returns #f.
@end deffn
-@deffn procedure char=? char1 char2 char3 @dots{}
-@deffnx procedure char<? char1 char2 char3 @dots{}
-@deffnx procedure char>? char1 char2 char3 @dots{}
-@deffnx procedure char<=? char1 char2 char3 @dots{}
-@deffnx procedure char>=? char1 char2 char3 @dots{}
+@deffn procedure char=? @vari{char} @varii{char} @variii{char}@dots{}
+@deffnx procedure char<? @vari{char} @varii{char} @variii{char}@dots{}
+@deffnx procedure char>? @vari{char} @varii{char} @variii{char}@dots{}
+@deffnx procedure char<=? @vari{char} @varii{char} @variii{char}@dots{}
+@deffnx procedure char>=? @vari{char} @varii{char} @variii{char}@dots{}
-These procedures return #t if the results of passing their arguments to char->integer
+These procedures return @code{#t} if the results of passing their arguments to @code{char->integer}
are respectively equal, monotonically increasing, monotonically decreasing,
monotonically non-decreasing, or monotonically non-increasing.
These predicates are required to be transitive.
+
@end deffn
-@deffn {char library procedure} char-ci=? char1 char2 char3 @dots{}
-@deffnx {char library procedure} char-ci<? char1 char2 char3 @dots{}
-@deffnx {char library procedure} char-ci>? char1 char2 char3 @dots{}
-@deffnx {char library procedure} char-ci<=? char1 char2 char3 @dots{}
-@deffnx {char library procedure} char-ci>=? char1 char2 char3 @dots{}
+@deffn {char library procedure} char-ci=? @vari{char} @varii{char} @variii{char}@dots{}
+@deffnx {char library procedure} char-ci<? @vari{char} @varii{char} @variii{char}@dots{}
+@deffnx {char library procedure} char-ci>? @vari{char} @varii{char} @variii{char}@dots{}
+@deffnx {char library procedure} char-ci<=? @vari{char} @varii{char} @variii{char}@dots{}
+@deffnx {char library procedure} char-ci>=? @vari{char} @varii{char} @variii{char}@dots{}
-These procedures are similar to char=? et cetera, but they treat upper case and lower
-case letters as the same. For example, (char-ci=? #\A #\a) returns #t.
+These procedures are similar to @code{char=?} et cetera, but they treat upper case and lower
+case letters as the same. For example, @code{(char-ci=? #\A #\a)} returns @code{#t}.
-Specifically, these procedures behave as if char-foldcase were applied to their
+Specifically, these procedures behave as if @code{char-foldcase} were applied to their
arguments before they were compared.
+
@end deffn
@deffn {char library procedure} char-alphabetic? char
@@ -89,18 +92,21 @@ arguments before they were compared.
@deffnx {char library procedure} char-upper-case? letter
@deffnx {char library procedure} char-lower-case? letter
-These procedures return #t if their arguments are alphabetic, numeric, whitespace,
-upper case, or lower case characters, respectively, otherwise they return #f. Specifically,
-they must return #t when applied to characters with the Unicode properties Alphabetic,
-Numeric_Type=Decimal, White_Space, Uppercase, and Lowercase respectively, and #f
+These procedures return @code{#t} if their arguments are alphabetic, numeric, whitespace,
+upper case, or lower case characters, respectively, otherwise they return @code{#f}.
+
+Specifically,
+they must return @code{#t} when applied to characters with the Unicode properties Alphabetic,
+Numeric_Type=Decimal, White_Space, Uppercase, and Lowercase respectively, and @code{#f}
when applied to any other Unicode characters. Note that many Unicode characters are
alphabetic but neither upper nor lower case.
+
@end deffn
@deffn {char library procedure} digit-value char
This procedure returns the numeric value (0 to 9) of its argument if it is a numeric digit
-(that is, if char-numeric? returns #t), or #f on any other character.
+(that is, if @code{char-numeric?} returns @code{#t}), or @code{#f} on any other character.
@lisp
(digit-value #\3) @result{} 3
@@ -113,35 +119,46 @@ This procedure returns the numeric value (0 to 9) of its argument if it is a num
@deffn procedure char->integer char
@deffnx procedure integer->char n
-Given a Unicode character, char->integer returns an exact integer between 0 and #xD7FF
-or between #xE000 and #x10FFFF which is equal to the Unicode scalar value of that
-character. Given a non-Unicode character, it returns an exact integer greater than
-#x10FFFF. This is true independent of whether the implementation uses the Unicode
-representation internally.
+Given a Unicode character,
+@code{char->integer} returns an exact integer
+between 0 and @code{#xD7FF} or
+between @code{#xE000} and @code{#x10FFFF}
+which is equal to the Unicode scalar value of that character.
+Given a non-Unicode character,
+it returns an exact integer greater than @code{#x10FFFF}.
+This is true independent of whether the implementation uses
+the Unicode representation internally.
+
+Given an exact integer that is the value returned by
+a character when @code{char->integer} is applied to it, @code{integer->char}
+returns that character.
-Given an exact integer that is the value returned by a character when char->integer is
-applied to it, integer->char returns that character.
@end deffn
@deffn {char library procedure} char-upcase char
@deffnx {char library procedure} char-downcase char
@deffnx {char library procedure} char-foldcase char
-The char-upcase procedure, given an argument that is the lowercase part of a Unicode
-casing pair, returns the uppercase member of the pair, provided that both characters
-are supported by the Scheme implementation. Note that language-sensitive casing pairs
-are not used. If the argument is not the lowercase member of such a pair, it is returned.
-
-The char-downcase procedure, given an argument that is the uppercase part of a
-Unicode casing pair, returns the lowercase member of the pair, provided that both
-characters are supported by the Scheme implementation. Note that language-sensitive
-casing pairs are not used. If the argument is not the uppercase member of such a pair, it
-is returned.
-
-The char-foldcase procedure applies the Unicode simple case-folding algorithm to its
-argument and returns the result. Note that language-sensitive folding is not used. If the
-character that results from folding is not supported by the implementation, the
-argument is returned. See UAX #44 [11] (part of the Unicode Standard) for details.
+The @code{char-upcase} procedure, given an argument that is the
+lowercase part of a Unicode casing pair, returns the uppercase member
+of the pair, provided that both characters are supported by the Scheme
+implementation. Note that language-sensitive casing pairs are not used. If the
+argument is not the lowercase member of such a pair, it is returned.
+
+The @code{char-downcase} procedure, given an argument that is the
+uppercase part of a Unicode casing pair, returns the lowercase member
+of the pair, provided that both characters are supported by the Scheme
+implementation. Note that language-sensitive casing pairs are not used. If the
+argument is not the uppercase member of such a pair, it is returned.
+
+The @code{char-foldcase} procedure applies the Unicode simple
+case-folding algorithm to its argument and returns the result. Note that
+language-sensitive folding is not used. If the argument is an uppercase
+letter, the result will be either a lowercase letter
+or the same as the argument if the lowercase letter does not exist or
+is not supported by the implementation.
+See UAX #29 (part of the Unicode Standard) for details.
+@c cite{uax29}
Note that many Unicode lowercase characters do not have uppercase equivalents.
@end deffn
