Numbers can be arranged in different subtypes, e.g.
For example, 2 is an integer, but it is also a rational, a real and a complex number.
Numbers can be represented both exactly and inexactly. A number is exact if it was written as an exact constant or was derived from exact numbers using only exact operations. Otherwise the number is inexact. The procedure inexact->exact is an exception to this rule.
A number may be expressed in binary, octal, decimal or hexadecimal by the use of a radix prefix: #b for binary, #o for octal, #d for decimal and #x for hexadecimal. If no prefix is specified the radix is in decimal by default.
(number? x) (complex? x) (real? x) (rational? x) (integer? x) (exact? x) (inexact? x) (zero? x) (positive? x) (negative? x) (even? x) (odd? x)
The names clearly imply what the procedures do, so we will only take a look at some examples:
> (number? 5) #t > (complex? 5) #t > (zero? 0) #t > (even? 0) #t > (odd? 10) #f > (exact? (* 5 5)) #t >(inexact? 3.1415) #t
Arithmetic operations can be performed with the corresponding operators, for example:
> (+ 2 3 4) 9 > (- 5 6) -1 > (* 1 2) 2 > (/ 1 2) 1/2 > (/ 1 2.0) 0.5 > (+ (* 3 4) 2) 14
+, - and * are guaranteed to return exact results if the arguments are exact. Some implementations regard division as an exact operation if the arguments are exact. However, if division is performed on exact numbers, which are very large, the computation might become very slow. In that case one argument should be given as an inexact number, because it will speed up the computation, but the result will no longer be exact. Unless exact numbers are required this should not be a problem. Inexact numbers can also be converted into exact numbers with the procedure inexact->exact.
There are also a couple of procedures which test whether their arguments are equal, monotonically increasing or decreasing or monotonically nonincreasing or decreasing. These are:
(= x1 x2 ...) (> x1 x2 ...) (< x1 x2 ...) (>= x1 x2 ...) (<= x1 x2 ...)
They return either #t or #f. For example:
> (< 3 4 5 6) #t > (<= 3 4 5 6) #t > (> 4 2 3 6) #f
Note that = should only be used with exact numbers even if it isn't an error to use it on inexact ones8.1. If used on inexact numbers, it might return something unexpected because of the representation of inexact numbers in the machine.
Scheme also provides various mathematical procedures:
(abs x) ; returns the absolute value of x
(acos x) ; returns the arccosine of x
(asin x) ; returns the arcsine of x
(atan x) ; returns the arctangent of x
(atan x1 x2) ; computes (angle (make-rectangular x2 x1))
(ceiling x) ; rounds x upwards
(cos x) ; returns the cosine of x
(denominator x) ; returns the denominator of x
(exp x) ; returns e^x
(expt n k) ; returns n^k
(floor x) ; rounds x downwards
(gcd x1 x2 ...) ; computes the greatest common divisor
(lcm x1 x2 ...) ; computes the least common multiple
(log x) ; returns the natural logarithm of x
(max x1 x2 ...) ; returns the largest of the arguments
(min x1 x2 ...) ; returns the smallest of the arguments
(modulo x1 x2) ; computes the modulo of the arguments
(numerator x) ; returns the numerator of the argument
(quotient x1 x2) ; returns the quotient of the arguments
(rationalize x1 x2) ; returns the simplest rational number differing
; from x1 no more than x2
(remainder x1 x2) ; returns the remainder of the arguments
(round x) ; rounds the argument (see the example below)
(sin x) ; returns the sine of x
(sqrt x) ; returns the square root of x
(tan x) ; returns the tangent of x
(truncate x) ; truncates x
For example, we can define 
by using the mathematical procedure
acos in the following way:
> (define pi (acos -1)) > pi 3.1415926535898
As can be seen from the list above, there are four procedures for rounding numbers.
The procedure round rounds the argument to the nearest integer, but if the arguments is halfway between two integers, it rounds it to the nearest even integer. For example:
> (round pi) 3.0 > (round 3.5) 4.0 > (round 2.5) 2.0 > (round -2.5) -2.0 > (round -3.4) -3.0 > (round -3.5) -4.0
The procedure truncate chops the decimal part of the argument:
> (truncate pi) 3.0 > (truncate 3.5) 3.0 > (truncate -3.5) -3.0
The procedure ceiling returns the smallest integer which is greater than or equal to the argument, for example:
> (ceiling pi) 4.0 > (ceiling 3.5) 4.0 > (ceiling -3.5) -3.0
The procedure floor returns the largest integer which is less than or equal to the argument, for example:
> (floor pi) 3.0 > (floor 3.5) 3.0 > (floor -3.5) -4.0
Scheme also provides some trigonometric functions. Note that the argument is in radians. For example:
> (sin pi) 0.0 > (cos pi) -1.0 > (- (tan pi) (/ (sin pi) (cos pi))) 0.0 > (sqrt (ceiling (abs (cos pi)))) 1.0
Some general procedures for complex numbers are also provided:
(make-rectangular x1 x2) ; constructs a complex number in rectangular form (make-polar x1 x2) ; constructs a complex number in polar form (real-part z) ; returns the real part of the complex number z (imag-part z) ; returns the imaginary part of the complex number z (magnitude z) ; returns the magnitude of the complex number z (angle z) ; returns the angle of the complex number z
For example,
> (define a (make-rectangular 3 4)) > a 3+4i > (real-part a) 3 > (imag-part a) 4 > (magnitude a) 5 > (angle (make-rectangular 3 4)) 0.92729521800161
Scheme also provides the procedures inexact->exact and exact->inexact for converting inexact numbers into exact and vice versa, for example:
> (inexact->exact 5.0) 5 > (exact->inexact 5) 5.0
The boolean objects are true and false and are written as #t and #f. All standard values in Scheme except #f count as true in conditional expressions.
Boolean constants evaluate to themselves and need not be quoted in programs, e.g.
> #f #f > #t #t
Scheme provides a predicate boolean? with the following syntax:
(boolean? x)
If x is either #t or #f, then #t is returned, otherwise #f is returned.
> (boolean? #t) #t > (boolean? '()) #f > (boolean? (eq? 'x '(x y z))) #t
Another procedure is not, which takes one argument and negates it:
> (not #f) #t > (not (= 5 4)) #t
Also the special forms and and or are used on boolean expressions.
Characters are letters, numbers and other symbols on the computer keyboard as well as some control characters such as newline and space. Characters are written using the notation #\<char> or #\<character name>. The former is case sensitive whereas the latter is not.
Example:
#\space #\newline #\s
Characters written in the #\ notation are self-evaluating.
Most of the procedures for characters are predicates. If the procedure ignores case it usually has -ci embedded in its name.
Scheme provides the procedure char?, which has the following syntax:
(char? x)
If x is a character, the procedure returns #t, otherwise it returns #f. For example:
> (char? #\a) #t > (char? 'a) ;; 'a is a symbol, not a character #f > (char? "a") ;; "a" is a string, not a character #f > (char? #\space) #t
There are also procedures for finding out whether a given character comes before or after another character in the alphabet. These are
(char=? ch1 ch2) ; Is ch1 the same character as ch2? (char<? ch1 ch2) ; Does ch1 come before ch2 in the alphabet? (char>? ch1 ch2) ; Does ch1 come after ch2 in the alphabet? (char<=? ch1 ch2) ; Does ch1 come before ch2 or are they both the same? (char>=? ch1 ch2) ; Does ch1 come after ch2 or are they both the same? (char-ci=? ch1 ch2) ; The same as char=? but case-insensitive (char-ci<? ch1 ch2) ; The same as char<? but case-insensitive (char-ci>? ch1 ch2) ; The same as char>? but case-insensitive (char-ci<=? ch1 ch2) ; The same as char<=? but case-insensitive (char-ci>=? ch1 ch2) ; The same as char>=? but case-insensitive
Note that the lower case letters are in order, the upper case letters are in order and the digits are in order and that all the upper case letters precede all the lower case or vice versa. Also note that all the digits either precede all the upper case letters or vice versa and that all the digits either precede all the lower case letters or vice versa.
The following example shows the use of the procedures mentioned above, but the result returned of the last expression is implementation-dependent:
> (char=? #\a #\A) #f > (char-ci=? #\a #\A) #t > (char<? #\a #\b) #t > (char>? #\a #\A) #t
Scheme also provides procedures for finding out what kind of character is in question, e.g. is it a digit, an alphabetic character...These procedures are:
(char-alphabetic? ch) (char-numeric? ch) (char-whitespace? ch) (char-upper-case? ch) (char-lower-case? ch)
Space, tab, line feed, form feed and carriage return are all regarded as whitespace characters.
For example:
> (char-alphabetic? #\a) #t > (char-numeric? #\a) #f > (char-numeric? #\2) #t > (char-upper-case? #\A) #t > (char-lower-case? #\A) #f
There are also procedures for converting characters to integers representing the character (e.g. in the ASCII character set) and vice versa. These procedures are char->integer and integer->char and have the following syntax:
(char->integer ch) (integer->char n)
and can be used for example in the following way:
> (char->integer #\3) 51 > (char->integer #\a) 97 > (integer->char 56) #\8 > (integer->char (char->integer #\b)) #\b
Note that the result returned by these procedures are implementation dependent.
Scheme also provides two procedures for converting upper case characters to lower case and vice versa. They are the following:
(char-upcase ch) (char-downcase ch)
For example:
> (char-upcase #\a) #\A > (char-downcase #\B) #\b > (char-downcase #\b) #\b > (char-downcase (char-upcase #\c)) #\c
Symbols are objects, whose usefulness rest on the fact that two symbols are equal if and only if their names are spelled the same way.
Scheme provides a predicate symbol?, which takes one argument and returns #t if the argument was a symbol and #f otherwise. For example,
> (symbol? 'boo) #t > (symbol? "boo") #f > (symbol? (car '(a b c))) #t > (symbol? '()) #f
There are also two procedures for converting a symbol to a string and vice versa, namely the procedures symbol->string and string->symbol. Note that the strings returned by symbol->string are immutable.
The procedures symbol->string and string->symbol work in the following way:
> (symbol->string 'foo) "foo" > (string->symbol "foo") foo > (symbol->string (string->symbol "bar")) "bar"
A string is written as a sequence of characters enclosed in double quotes. The length of the string is the number of characters it contains. The first character has the index value zero. Doublequotes can be written inside a string by escaping them with a backslash.
Example:
"This is a string and \"this is a string\" is also a string."
Scheme provides a predicate string? for testing whether a given object is a string. It has the following syntax:
(string? str)
If str is a string, #t is returned, otherwise #f is returned. For example,
> (string? "boo") #t > (string? 'boo) ; false, because 'boo is a symbol #f > (string? 5) ; false, because 5 is a number #f > (string? "") #t
Scheme also provides a variety of predicates for determining the lexicographic order of two strings. If two strings differ in length in such a way that one is the prefix of the other, the shorter string is considered to be lexicographically less than the other. The procedures can be regarded as extensions to strings of the corresponding orderings of characters.
The predicates are the following:
(string=? str1 str2) ; Is str1 the same as str2? (string<? str1 str2) ; Is str1 lexicographically less than str2? (string>? str1 str2) ; Is str2 lexicographically less than str1? (string<=? str1 str2) ; Is str1 lexicographically less than or equal to str2? (string>=? str1 str2) ; Is str2 lexicographically less than or equal to str1? (string-ci=? str1 str2) ; The same as string=? but case-insensitive (string-ci<? str1 str2) ; The same as string<? but case-insensitive (string-ci>? str1 str2) ; The same as string>? but case-insensitive (string-ci<=? str1 str2) ; The same as string<=? but case-insensitive (string-ci>=? str1 str2) ; The same as string>=? but case-insensitive
The procedures containing -ci are case-insensitive. For example:
> (string=? "foo" "FOO") ; false, considered as different strings #f > (string-ci=? "foo" "FOO") ; true, the procedure is case-insensitive #t > (string<? "bar" "foo") ; true, since bar comes before foo #t > (string<? "foobar" "foo") ; false, foo is a prefix of and "less than" foobar #f
Scheme also provides various procedures for creating and manipulating strings. Strings can be created with the procedures make-string and string. They have the following syntax:
(make-string n) (make-string n ch) (string ch1 ch2 ...)
It is also possible to create a string using doublequotes. Such strings are so called string constants and cannot be changed later with procedures such as string-set!. For example:
> "foo" "foo"
Even if some implementations allow changing constant strings, you should not be tempted to do so!
The procedure make-string takes either one or two arguments, where n is the number of characters and ch represents the character. If ch is given, all characters in the string will be initialied to ch, otherwise the contents of the string are implementation-dependent. The procedure string takes an arbitrary number of characters and returns a string composed of the given characters. For example:
> (make-string 10 #\a) "aaaaaaaaaa" > (string #\S #\c #\h #\e #\m #\e) "Scheme"
The length of the string is the number of characters it is composed of. The length of the empty string is 0. Scheme provides a procedure for computing the length of the string, namely string-length, which takes one string as an argument and returns an integer. For example:
> (string-length "Scheme") 6 > (string-length "This is a very clever sentence") 30 > (string-length "") 0
Strings can also be concatenated using string-append, which takes an arbitrary number of arguments and returns a newly allocated string composed of the characters of the strings given as arguments. For example:
> (string-append "foo" "bar" "foo" "bar" "foobar") "foobarfoobarfoobar" > (string-append "Hello!" " " "My name is Torsten") "Hello! My name is Torsten" > (string-append) ""
It is also possible to extract characters from a string using the string-ref procedure, which takes a string and an integer n and returns the nth character. Note that the first character has the index 0. For example:
> (string-ref "foobar" 0) #\f > (string-ref "foobar" 1) #\o > (string-ref "foobar" 10) string-ref: index 10 out of range [0, 5] for string: "foobar"
Scheme also provides a procedure substring with the following syntax:
(substring str start end)
str must be a string and start and end are integers
such that
the length of the string.
For example:
> (substring "foobar" 1 3) "oo" > (substring "foobar" 0 0) ""
Scheme provides procedures for converting strings to lists of characters and vice versa. These are string->list and list->string and work in the following way:
> (string->list "foobar") (#\f #\o #\o #\b #\a #\r) > (list->string '(#\f #\o #\o #\space #\b #\a #\r)) "foo bar" > (list->string '()) "" > (string->list "") ()
Strings can be copied with the string-copy procedure, which takes a string to be copied as argument and returns a newly allocated copy of the argument. For example:
> (string-copy "foobar") "foobar" > (define a "foobar") > (define b (string-copy a)) > b "foobar"
There are two procedures causing side effects, namely string-set! and string-fill!. The procedure string-set! has the following syntax:
(string-set! str n ch)
and stores ch in element n of str. The value returned is unspecified.
For example:
> (define str (string #\f #\o #\o #\b #\a #\r)) > str "foobar" > (string-set! str 2 #\d) > str "fodbar" > (string-set! str 0 #\b) > str "bodbar"
The procedures string-set! and string-copy are often used together. We might, for example, want a copy of a given string, which we want to change without changing the original string:
> (define str (string #\f #\o #\o #\b #\a #\r)) > (define foo (string-copy str)) > str "foobar" > foo "foobar" > (string-set! foo 0 #\g) > str "foobar" > foo "goobar"
The procedure string-fill! has the following syntax:
(string-fill! str ch)
and stores ch in every element of str as a side effect. The return value is unspecified.
For example:
> (define str (string #\f #\o #\o #\b #\a #\r)) > (string-fill! str #\a) > str "aaaaaa"
For example:
(cons 1 2)
constructs a pair consisting of the two integers 1 and 2. The external representation of this pair is (1 . 2). If we wish to give our compound data object a name, we can use define as we are used to:
(define a (cons 1 2))
If we wish to extract the first integer in the pair, we use car
>(car a) 1
and if we wish to extract the second integer, we use cdr:
>(cdr a) 2
(2 4 6 8 10)
In other words, a list is a chain of pairs ending in the empty list. If the chain of pairs does not end with the empty list, the list is said to be improper. An improper list is not a list!
The empty list is denoted (). The list (2 4 6 8 10) is the same as (2 . (4 . (6 . (8 . (10 . ()))))). An improper list can be represented using dotted notations in the following way: (2 4 6 8 . 10), which is equivalent to (2 . (4 . (6 . (8 . 10)))).
Note that lists should be quoted when fed to the interpreter, otherwise the interpreter will try to apply the first item in the list to the other items in the list, e.g.
> (2 4 6 8) procedure application: expected procedure, given: 2; arguments were: 4 6 8 > '(2 4 6 8) (2 4 6 8)
Lists can be constructed using cons in the following way:
(cons 2 (cons 4 (cons 6 (cons 8 (cons 10 '())))))
Note that
(cons 1 (cons 2 '()))
is a list, whereas
(cons 1 2)
is not. The latter is a pair. A list is constructed from pairs and is consiedered a pair, but a pair is not in itself a list! The empty list is, however, not a pair.
Lists can also be constructed using the procedure list as follows:
(list 2 4 6 8 10)
If we wish to take lists apart, we can use car and cdr and combinations thereof. For example:
>(car (list 2 4 6 8 10)) 2
whereas
>(cdr (list 2 4 6 8 10)) (4 6 8 10)
The result of applying cdr to a list is always a list.
Let's say that we want to extract the second element in the list. In order to accomplish this we can combine car and cdr in the following way:
>(car (cdr (list 2 4 6 8 10))) 4
There is a shortening for combined car:s and cdr:s. The same could be accomplished as follows:
>(cadr (list 2 4 6 8 10)) 4
car:s and cdr:s can be combined four times. Hence, the following combinations exist:
(caar ls) ; is the same as (car (car ls)) (cadr ls) ; is the same as (car (cdr ls)) (cdar ls) ; is the same as (cdr (car ls)) (cddr ls) ; is the same as (cdr (cdr ls)) (caaar ls) ; is the same as (car (car (car ls))) (caadr ls) ; is the same as (car (car (cdr ls))) (cadar ls) ; is the same as (car (cdr (car ls))) (caddr ls) ; is the same as (car (cdr (cdr ls))) (cdaar ls) ; is the same as (cdr (car (car ls))) (cdadr ls) ; is the same as (cdr (car (cdr ls))) (cddar ls) ; is the same as (cdr (cdr (car ls))) (cdddr ls) ; is the same as (cdr (cdr (cdr ls))) (caaaar ls) ; is the same as (car (car (car (car ls)))) (caaadr ls) ; is the same as (car (car (car (cdr ls)))) (caadar ls) ; is the same as (car (car (cdr (car ls)))) (caaddr ls) ; is the same as (car (car (cdr (cdr ls)))) (cadaar ls) ; is the same as (car (cdr (car (car ls)))) (cadadr ls) ; is the same as (car (cdr (car (cdr ls)))) (caddar ls) ; is the same as (car (cdr (cdr (car ls)))) (cadddr ls) ; is the same as (car (cdr (cdr (cdr ls)))) (cdaaar ls) ; is the same as (cdr (car (car (car ls)))) (cdaadr ls) ; is the same as (cdr (car (car (cdr ls)))) (cdadar ls) ; is the same as (cdr (car (cdr (car ls)))) (cdaddr ls) ; is the same as (cdr (car (cdr (cdr ls)))) (cddaar ls) ; is the same as (cdr (cdr (car (car ls)))) (cddadr ls) ; is the same as (cdr (cdr (car (cdr ls)))) (cdddar ls) ; is the same as (cdr (cdr (cdr (car ls)))) (cddddr ls) ; is the same as (cdr (cdr (cdr (cdr ls))))
For example:
>(caddr (list 2 4 6 8 10)) 6 >(car (cdr (cdr (list 2 4 6 8 10)))) 6
These procedures can also be combined if the standards ones are insufficient. For example:
> (define ls '(((((((1 2) 3) 4) 5) 6) 7) 8)) > (caaaar ls) (((1 2) 3) 4) > (car (caaaar ls)) ((1 2) 3) > (cdaar (caaaar ls)) (2)
Scheme also provides the procedures set-car! and set-cdr! for explicitly changing the value of the car or cdr of a list. This is done as a side effect and the return value is unspecified.
> (define ls (list 1 2 3 4 5)) > ls (1 2 3 4 5) > (set-car! ls 10) > ls (10 2 3 4 5) > (set-cdr! ls '()) > ls (10)
Note that lists created in the following way cannot be changed using set-car! or set-cdr!:
> (define ls '(1 2 3 4 5))
This is because ls is now a list constant that cannot be changed. Don't be tempted to do it incorrectly even if the implementation allows it.
Care should be taken when using set-car! and set-cdr!. For example: when using set-cdr!, we may run into situations in which the object is a list at first, but after application of set-cdr! it is not.
The length of a list is the number of top-level items in it. Scheme provides a procedure length for computing the length of the list, which is given as an argument. For example:
>(length (list 2 4 6 8 10)) 5
The length of the empty list is 0.
> (length '()) 0
There are a couple of predicates for pairs and lists, namely pair?, list? and null?. They have the following syntax:
(pair? x) (list? x) (null? x)
The predicate pair? returns #t if x is a pair, otherwise it returns #f. The predicate list? returns #t if x is a proper list and #f otherwise. The predicate null? returns #t if x is the empty list and #f otherwise.
> (pair? (list 1 2 3 4)) #t > (pair? (cons 1 2)) #t > (pair? '()) #f > (pair? (car '(1 2 3))) #f > (pair? (cdr '(1 2 3))) #t > (pair? (car '((1 2) 3 4))) #t > (pair? (cdr '(1 2))) #t
The first example is considered a pair, since a list is a chain of pairs ending in the empty list. The second example is naturally a pair, but the third one, namely the empty list, is not a pair. Numbers are not pairs either, so if the car of the list whose first item is not a pair or a list is tested using pair?, then #f will be returned. If the first element, on the other hand, is a pair or a list, then #t will be returned. One might wonder, why the procedure in the last example returns #t instead of #f. This is because (1 2) is a list and lists always end with the empty list, so the cdr of (1 2) is not 2, but (2)!
> (list? (list 1 2 3 4)) #t > (list? (cons 1 2)) #f > (list? (cons 1 (cons 2 '()))) #t > (list? '()) #t > (list? '(a . b)) #f
The first example is obviously a list, but the second is not, since a pair is not a list. Lists end in the empty list, so the third example is a list. Also the empty list alone is a list. The last example yields false, because the list '(a . b) is not a proper list.
The predicate null? can be used as follows:
> (null? '(1 2 3)) #f > (null? '()) #t > (null? #f) #f
If we wish to address a given element in a list we might want to use list-ref, which takes two arguments, a list ls and an integer n and returns the n:th item in ls. For example:
>(list-ref '(1 2 3 4) 2) 3 > (list-ref '(1 2 3 4) 0) 1 > (list-ref '(1 2 3 4) 5) list-ref: index 5 too large for list: (1 2 3 4)
Note that the index of the first item is 0! It is illegal to try to reference an item with an index number larger than or equal to the length of the list.
If we want to return the sublist of a given list by omitting the first n items, we may use the procedure list-tail, which takes two arguments, a list and an integer n as follows:
> (list-tail '(1 2 3 4 5) 2) (3 4 5) > (list-tail '(1 2 3 4 5) 0) (1 2 3 4 5) > (list-tail '(1 2 3 4 5) 5) () > (list-tail '(1 2 3 4 5) 7) list-tail: index 7 too large for list: (1 2 3 4 5)
As we can see, it is an error if n is larger than the length of the list.
To reverse the order of items in a list we can use the procedure reverse as follows:
>(reverse '(1 2 3 4)) (4 3 2 1) > (reverse '((1 2) (3 4) (5 6))) ((5 6) (3 4) (1 2))
Scheme also provides a procedure append for appending lists, which are given as arguments:
> (append '(1 2 3) '(4 5 6)) (1 2 3 4 5 6) > (append '() '(1)) (1) > (append '(1 2 (3 4)) '()) (1 2 (3 4)) > (append '(1 2 3) '(4 5 6) '(7 8 9)) (1 2 3 4 5 6 7 8 9)
The resulting list is almost always newly allocated, but it shares structure with the last argument. If the last argument is not a proper list, then applying append will result in an improper list:
> (append '(1 2) 'b) (1 2 . b) > (append '() 'c) c
There are also a couple of procedures for finding out whether a given element can be found in a list, namely memq, memv and member. These are not considered to be predicates, because they return useful values instead of merely #t or #f. The syntax is as follows:
(memq x ls) (memv x ls) (member x ls)
The difference between them is that memq uses eq? to compare, memv uses eqv? and member uses equal?8.2. The usage and return values of these procedures can best be described with a few examples:
> (memq 'a '(a b c)) (a b c) > (memq 'b '(a b c)) (b c) > (memv 'a '(a b c)) (a b c) > (member 'a '(a b c)) (a b c) > (memq 'a '(b c d)) #f > (memv 'a '(b c d)) #f > (member 'a '(b c d)) #f
As we can see, the procedures return the same values for top-level items. Note that #f is returned if the element cannot be found instead of the empty list!
> (memq '(2 3) '((2 3) 4)) #f > (memv '(2 3) '((2 3) 4)) #f > (member '(2 3) '((2 3) 4)) ((2 3) 4)
The procedure member, which uses equal? to compare the contents of the list, is the only one that returns #t because equal? checks if two objects have the same value (e.g. if two lists contain the same items) as opposed to eq? and eqv? that check if two objects refer to the same place.
There are also three procedures for finding the first pair with a given car field in an association list, namely assq, assv and assoc. They have the following syntax:
(assq x als) (assv x als) (assoc x als)
An association list is a list of pairs, for example: ((x 10) (y 20) (z 30)). Let's take a look at a few examples:
> (define als '((x 10) (y 20) (x 30))) > (assq 'a als) #f > (assq 'x als) (x 10) > (assq 'y als) (y 20) > (assv 'x als) (x 10) > (assoc 'x als) (x 10) > (assoc (list 'x) '(((x)) ((b)) ((c)))) ((x))
The difference between assq, assv and assoc is that assq uses eq? to compare, assv uses eqv? and assoc uses equal?.
Another extremely useful procedure in Scheme is map, which takes a procedure and an arbitrary number of lists as arguments and returns a list. If one list is given as an argument, the procedure will be applied to each element of the list. If two or more lists are given as arguments, the procedure is applied to each nth item of each list. The lists must all be of the same length. The procedure must of course be applicable to the elements in the list, otherwise an error will occur. Let's say we want to add one to each element in the list (1 2 3 4 5). This can be done in the following way:
> (map (lambda (x) (+ x 1)) '(1 2 3 4 5)) (2 3 4 5 6)
Let's say that we want to compute the factorial of each element in the list. The easiest way is to first define a procedure for computing the factorial of an integer and then feed the procedure to map as follows:
(define fact
(lambda (n)
(if (= n 0)
1
(* n (fact (- n 1)))))
> (map fact (list 1 2 3 4 5))
(1 2 6 24 120)
Now we might want to raise the factorial of each element in the list to a given power. This requires a function taking two arguments. So, how can we accomplish our task? Let's start by defining a procedure for raising the factorial of a number to a given power:
(define fact-expt
(lambda (n e)
(expt (fact n) e)))
In order to use the procedure we can use map and keep the value of e, the second argument of fact-expt, constant in the following way:
> (map (lambda (x) (fact-expt x 1)) (list 1 2 3 4 5)) (1 2 6 24 120) > (map (lambda (x) (fact-expt x 2)) (list 1 2 3 4 5)) (1 4 36 576 14400) > (map (lambda (x) (fact-expt x 3)) (list 1 2 3 4 5)) (1 8 216 13824 1728000)
Note that map only works on the top-level items of a list.
If two or more lists are given as arguments to map, the procedure will be applied to each nth element of the lists, e.g:
> (map + '(1 2 3) '(1 2 3)) (2 4 6) > (map * '(1 2 3) '(1 2 3) '(1 2 3)) (1 8 27)
Another procedure resembling map but used only for its side effects is for-each, which has the following syntax:
(for-each proc ls1 ls2 ...)
The difference between map and for-each is that the latter is guaranteed to apply the procedure to the elements in the order they appear. Also note that map returns a list, whereas the return value of for-each is unspecified. Let's look at a quick example:
> (for-each
(lambda (x)
(begin
(display x)
(newline)))
'(I am the greatest))
i
am
the
greatest
In fact, for-each is commonly used for input and output.
Sometimes we want to apply a procedure to a list using the items of the list as arguments to the procedure. Scheme has a procedure apply for this purpose. apply has the following syntax:
(apply proc arg1 ... args)
The argument proc must be a procedure and args must be a list. The other arguments may be of any type as long as the procedure given is applicable. The usage of apply is best described with a few examples:
>(apply + 1 2 '(3)) 6 > (apply + '(1 2 3)) 6 > (apply - 1 2 3 4 '()) -8 > (apply * (map (lambda (x) (fact x)) '(1 2 3))) 12
Vectors are data types that associate elements with an integer starting from zero. The difference between vectors and lists are that vectors usually occupy less space than the corresponding list and the time required to access a random element is constant. Most of the procedures operating on lists are linear in time.
Vectors are represented as #(obj ...), for example:
#((2 4 6 8) 1 "Scheme")
The length of a vector is the number of elements it contains. The length of the vector above is hence 3.
Scheme provides a predicate vector? for determining whether a given object is a vector or not. For example:
> (vector? '(1 2 3 4)) #f > (vector? '#(1 2 3 4)) #t
There is a variety of procedures for creating and manipulating vectors. Vectors can be created with the procedures vector and make-vector. The procedure vector takes an arbitrary number of arguments and returns a newly allocated vector containing the arguments as elements, for example:
> (vector 'a 'b "foobar" '(1 2 3 4) '#(another vector)) #(a b "foobar" (1 2 3 4) #(another vector)) > (vector) #()
The procedure make-vector has the following syntax:
(make-vector n) (make-vector n k)
If k is given, a newly allocated vector consisting of n elements, which all are k, will be returned. Otherwise, the contents of the vector returned will be unspecified. For example:
> (make-vector 3)
#(0 0 0)
> (make-vector 3 "foobar")
#("foobar" "foobar" "foobar")
The length of the vector is the number of elements in it. Scheme provides a procedure vector-length, which takes a vector as argument and returns the length of the vector as follows:
> (vector-length '#(a b c d)) 4 > (vector-length '#(a b #(a b) '(a b))) 4 > (vector-length '#()) 0
To reference an item in the vector, you can use the procedure vector-ref, which takes a vector and an integer n as arguments and returns the n:th element in the vector. Note that the first element is indexed as 0.
> (vector-ref '#(1 2 3 4) 2) 3 > (vector-ref '#(1 2 3 4) 0) 1
Vectors can be converted to lists and vice versa with the procedures vector->list and list->vector. For example:
> (vector->list '#(1 2 3 4)) (1 2 3 4) > (list->vector '(1 2 3 4)) #(1 2 3 4)
Scheme provides a procedure vector-set!, which has the following syntax:
(vector-set! vec n k)
and stores the object k in index n of the vector vec. The return value is unspecified.
For example:
> (define v (vector 'a 'b 'c 'd)) > (vector-set! v 0 1) > v #(1 b c d) > (vector-set! v 3 '(a list of elements)) > v #(1 b c (a list of elements))
Note that the procedure vector-set! cannot be used on vector constants.
Another procedure causing side effects is vector-fill!, which has the following syntax:
(vector-fill! vec k)
It stores k in every element of vec. The return value is unspecified. For example:
> (define v (vector 1 2 3 4)) > v #(1 2 3 4) > (vector-fill! v '(1 2)) #((1 2) (1 2) (1 2) (1 2))
The procedure vector-fill! cannot be used on vector constants either.
Note that even if the implementation returns something useful, as it did in our example above, procedures which are used for their side effects (such as vector-fill!) should never be used for the values they might return.