A string is a sequence of zero or more characters. Most strings can be
named by enclosing the characters they contain between double quotation
marks: for instance, "hyperbola" is the nine-character string
consisting of the characters #\h, #\y,
#\p, #\e, #\r, #\b,
#\o, #\l, and #\a, in that order,
and "" is the zero-character string (the null
string).
Strings may contain spaces and newline characters; when such characters are
between double quotation marks, they are treated like any other
characters. There is a slight problem when one wants to put a double
quotation mark into a string: To indicate that the double quotation mark
is part of the string (rather than marking the end of the string), one must
place a backslash character immediately in front of it. For instance,
"Say \"hi\"" is the eight-character string consisting of the
characters #\S, #\a, #\y,
#\space, #\", #\h, #\i,
and #\", in that order. The backslashes are escape
characters, present in the name only to indicate that the characters
immediately after them form part of the string.
This use of the backslash character causes yet another slight problem:
What if one wants to put a backslash into a string? The solution is to
place another backslash character immediately in front of it. For instance,
"a\\b" is the three-character string consisting of the
characters #\a, #\\, and #\b, in
that order.
Scheme provides several basic procedures for working with strings:
The string? predicate determines whether its argument is or is
not a string.
Is the symbol hyperbola a string?
Is the character #\A a string?
Does the null string count as a string?
The make-string procedure constructs and returns a string that
consists of repetitions of a single character; its first argument indicates
how long the string should be, and the second argument specifies which
character it should be made of. For instance, (make-string 5
#\a) constructs and returns the string "aaaaa".
The string procedure takes any number of characters as
arguments and constructs and returns a string consisting of exactly those
characters. For instance, (string #\H #\i #\!) constructs and
returns the string "Hi!".
Suggest two ways of constructing the string ??? -- one
using a call to make-string, the other a call to
string.
The string-length procedure takes any string as argument and
returns the number of characters in that string. For instance, the value
of (string-length "parabola") is 8 and the value of
(string-length "a\\b") is 3.
The string-ref procedure is used to select the character at a
specified position within a string. Like list-ref,
string-ref presupposes zero-based indexing; the
position is specified by the number of characters that precede it in the
string. (So the first character in the string is at position 0, the second
at position 1, and so on.) For instance, the value of (string-ref
"ellipse" 4) is #\p -- the character that follows four
other characters and so is at position 4 in zero-based indexing.
Here are two opposing views about the relationship between
string-length and string-ref:
``No matter what string str is, provided that it's not the
null string, (string-ref str (string-length str)) will return
the last character in the string.''
``No matter what string str is, (string-ref str
(string-length str)) is an error.''
Which, if either, of these views is correct? Why?
Strings can be compared for ``lexicographic order,'' the extension of
alphabetical order that is derived from the collating sequence of the local
character set. Once more, Scheme provides both case-sensitive and
case-insensitive versions of these predicates: string<?,
string<=?, string=?, string>=?,
and string>? are the case-sensitive versions, and
string-ci<?, string-ci<=?,
string-ci=?, string-ci>=?, and
string-ci>? the case-insensitive ones.
The substring procedure takes three arguments. The first is a
string and the second and third are non-negative integers not exceeding the
length of that string. Substring returns the part of its
first argument that starts after the number of characters specified by the
second argument and ends after the number of characters specified by the
third argument. For instance: (substring "hypocycloid" 3
8) returns the substring "ocycl" -- the substring that
starts after the initial "hyp" and ends after the eighth
character, the l.
The string-append procedure takes any number of strings as
arguments and returns a string formed by concatenating those arguments.
For instance, the value of (string-append "al" "fal" "fa") is
"alfalfa".
Write a Scheme procedure tally-vowels that takes one argument,
a string, and determines how many characters in that string are vowels.
(For this purpose, you should count only the ten characters
#\a, #\e, #\i, #\o,
#\u, #\A, #\E, #\I,
#\O, and #\U as vowels.)
Write a Scheme procedure consonant-part that takes one
argument, a string, and returns a string similar to its argument except
that all of the vowels have been removed. (For instance, the value of
(consonant-part "asparagus") should be "sprgs".)
This document is available on the World Wide Web as
http://www.math.grin.edu/~stone/courses/scheme/strings.html
created March 5, 1997
last revised May 31, 1998
Henry Walker (walker@math.grin.edu) and John David Stone (stone@math.grin.edu)