Purpose: Vectors, strings, characters and keywords.

6.1 Types - the story so far
 
 

6.2 Vectors

We have now met and played extensively with lisp's most flexible compound data type: the list. (To be pedantic, we met the cons, and you can use conses to build lists. Enough.) Lisp has plenty of other ways of grouping data together...

The function vector generates vectors (one-dimensional arrays) in exactly the same way as list generates lists. It can take any number of arguments and will generate a vector of that length:

   (vector 'foo "bar" 99)  =>  #(foo "bar" 99)
   (list 'foo "bar" 99)  =>  (foo "bar" 99)

Or, if you want to generate a vector and all you know at this stage is its length, you can use make-array (and btw there is a list equivalent called make-list, although in practice it's not very useful - why? - and therefore is not used much).

   (make-array 5)  =>  #(nil nil nil nil nil)   ; stuffed with nil
   (make-list 5)   =>  (nil nil nil nil nil)    ; ditto

Note how vectors print out: #( .... ). In fact (syntactic sugar) you can use the #() syntax to input a vector in the first place:

CL-USER 2 > #(foo "bar" 99)
#(FOO "bar" 99)

CL-USER 3 >

Vectors are of type vector, and the predicate vectorp is true of them.

The functions length and reverse from last week can be used on vectors as well as on lists:

(length #(foo "bar" 99))   =>  3
(length #())               =>  0     ; the empty vector
(reverse #(foo "bar" 99))  =>  #(99 "bar" foo)

(setf wibble #(foo "bar" 99))   =>  #(foo "bar" 99)
wibble                          =>  #(foo "bar" 99)
(aref wibble 0)                 =>  foo
(aref wibble 1)                 => "bar"
(setf (aref wibble 2) 'wombat)  =>  wombat
wibble                          =>  #(foo "bar" wombat)

• aref accesses the first element of a vector with argument 0 (like nth), and so on
• aref takes the vector as its first argument and the index as its second argument (regrettably unlike nth, which takes the index as its first argument and the list as its second argument)
• if you give an index which is out of range, you get an error (also unlike nth, which cheerfully returns nil if you fall off the end of a list)
CL-USER 5 > (aref #(foo "bar" 99) 99)

Error: The subscript 99 exceeds the limit 2 for the first dimension of the array #(FOO "bar" 99).

• aref takes the same time to access the 5000th member of a vector as it does to access the first (also unlike nth, which will take ~5000 times longer)

What you should be aware of, but is not "part of this course":

• A vector can be thought of as a one-dimensional array. Lisp supports multi-dimensional arrays, if you need them.
• If you really really really think you need to adjust the length of a vector after you created it (this is known as having your cake and eating it) it is possible, but be aware that it won't be cheap at runtime. You can also displace one array into another. We won't mess with either of these, which means that our vectors are known as simple vectors (hence the simple in simple-base-string).
• If you want efficiency, you can tell lisp in advance that all the members of a vector are of a particular type. For some types, eg numbers, this will enable lisp to pack them in tighter and can reduce access times (and duration of garbage collections). If you want to, read up about an array's element-type and the function upgraded-array-element-type.

(defun sum-members-of-vector (vec)
  (let* ((total 0))
    (dotimes (i (length vec))
      (incf total (aref vec i)))
    total))

(defun vector-to-list (vec)
  (let* ((new-list nil))
    (dotimes (i (length vec))
      (push (aref vec i) new-list))
    (reverse new-list)))

(defun list-to-vector-a (list)
  (let* ((length (length list))
         (vec (make-array length)))
    (dotimes (i length)
      (setf (aref vec i) (pop list)))
    vec))

(defun list-to-vector-b (list)
  (let* ((length (length list))
         (vec (make-array length))
         (i 0))
    (dolist (thing list)
      (setf (aref vec i) thing)
      (incf i))
    vec))

We've also met and played with strings. Here is a string: "Lisp is so wonderful". We have also met a couple of ways of generating strings: typing them in between quotation marks, and using (format nil ...). Another is to use the function make-string:

(make-string 5)  =>  some string of length 5 filled with random garbage

Any string is also a vector (we might say that string is a subtype of vector - see the figure in 6.1 above), so any operation you can perform on a vector can also be performed on a string. For instance, you can ask for its length, you can reverse it (as ever, this gives you a fresh string and reverses that, the original string remaining unchanged), you can aref into it to get your hands on individual characters and (setf aref) to modify them.

(setf my-string "Lisp is great")          =>  "Lisp is great"
(length my-string)                        =>  13
(reverse my-string)                       =>  "taerg si psiL"
my-string                                 =>  "Lisp is great"
(aref my-string 0)                        =>  #\L
(aref my-string (1- (length my-string)))  =>  #\t
(setf (aref my-string 6) #\t)             =>  #\t
my-string                                 =>  "Lisp it great"

(typep my-string 'string)        =>  t
(typep my-string 'vector)        =>  t
(typep #() 'string)              =>  nil

(stringp my-string)              =>  t
(vectorp my-string               =>  t
(stringp #())                    =>  nil

If you want to compare a whole load of characters to see if they're the same, use char=
    (char= #\a #\a #\a)  =>  t
    (char= #\A #\a #\a)  =>  nil
And there is a case-insensitive version of char= called char-equal
    (char-equal #\A #\a #\A)  =>  t

If you are desperate to convert between characters and their ASCII values, the functions char-code and code-char will assist:

(char-code #\p)  =>  112
(code-char 112)  =>  #\p

(let ((characters '(#\x #\8 #\*)))
  (list (mapcar 'alpha-char-p characters)
        (mapcar 'digit-char-p characters)
        (mapcar 'alphanumericp characters)))
=>
((t nil nil) (nil 8 nil) (t t nil))  ; the 8, while inelegant, is non-nil

(string-capitalize "ethel the aardvark")  =>  "Ethel The Aardvark"
(string-downcase "Ethel The Aardvark")    =>  "ethel the aardvark"
(string< "Earlier" "Later")               =>  t  ; alphabetical ordering
(char-name #\x)                           =>  "Latin-Small-Letter-X"

(make-array 5 :element-type 'standard-char)

The other way is the function read-line which can be used for reading strings from the listener. When read-line is called, the system waits for keyboard input. Everything typed up to (but not including) the next #\Newline is returned in a fresh string. For example,

CL-USER 10 > (read-line)
This is what I typed to generate a string which read-line returned.
"This is what I typed to generate a string which read-line returned."
NIL

CL-USER 11 >

6.4 Quick digression - keywords

Anyone who's still awake will have noticed the (a) the colon before the symbol element-type above and (b) that I didn't quote the symbol.

A symbol preceded by a colon is called a keyword. Keywords are symbols (so they respond warmly to symbolp) but they are distinguished by always being self-evaluating.

:brand-new-keyword  =>  :brand-new-keyword

(OK, so we didn't cover defconstant before. It's like defparameter except that you guarantee not to go changing that symbol's value later on. So (defconstant foo 99) followed by (setf foo 88) signals an error.)

Keywords are mainly used in complex argument lists with lots of optional arguments. We'll come back to this later, but here's an example: the function string=. This takes two strings (let's call them string1 and string2) and returns true if they match, character for character. It's case-sensitive (use string-equal if you want case-insensitive). You can optionally specify that you only want to compare part of either string (or both), by means of the keyword arguments :start1 :start2 :end1 :end2 (which are zero-based, and which default to the start and end of the respective strings if you don't specify them). string= returns true if the supplied substrings are of the same length and contain the same characters in corresponding positions; otherwise it returns nil.

(string= "I love lisp" "lisp is wonderful" :start1 7 :end2 4)  =>  t

[There is a convention that a :start argument points to the first character in the substring, and an :end argument points to the character following the end of the substring. Brownie points / smarties for telling me why.]

6.5 Practical session

Write a program to ask the user to type in a sentence, read it using read-line and then count how many words there were in this sentence.

6.6 Suggested activity / exercises etc

1. Go through Chapter 4 of Graham (omit sections 6,7 and 8) and then exercises 1 and 2 at the end of it.
2. Suppose you have been given a string and you want to find out how often each (alphabetical, i.e. ignore spaces, puncuation and the like) character occurs in it. Implement a function to solve this problem for you. [Some of you will have seen a similar problem before.] Hints:
• string-downcase
• char-code
• make-array - this takes a keyword argument :initial-element which you can use to fill the array with some starting value other than nil and  you may find this feature useful here. For example try out both of the following:
(make-array 5)
(make-array 5 :initial-element 'foo)
• dotimes
• incf
3. Keen observers of section 6.3 will have asked by now why we can't use equal rather than char=. The answer is that char= can compare more than two values in one function call, which might sometimes (though not often, I'll grant you) be useful; on the other hand equal takes precisely two arguments. Write a version of equal which takes any number of arguments. Since you don't yet know how to define a function which takes a completely variable number of arguments, pass them all in a single list. For example:
(better-equal '("aardvark" "aardvark" "aardvark" "aardvark"))  =>  t
(better-equal '("aardvark" "aardvark" "aardvark" "goat"))      =>  nil
4. Implement a function which takes two arguments, a list and a vector, and determines whether they have the same elements (in the same order). If you did this iteratively, now do it again recursively. Or vice versa.
5. Look up how the function subseq works. It is not part of the lecture course, but has been useful to students attempting the assignments.

Pick one or both of the assignments and work on it in parallel with the rest of this course.