1. Data Structures in Lisp
0. Collections of associations, association lists
1. Creating graphs with conses RPLACA and RPLACD (destructive editing)
2. Adjacency lists
3. Sequences
4. Arrays
5. Hash tables
6. Strings
CSE (c) S. Tanimoto, Lisp Data Structures

2. Collections of Associations
A collection of associations can be thought of as a set, a function, or a many-many mapping.
CONS is the fundamental mechanism for association in Lisp. An association list is a list of CONSes.
However, for reasons of efficiency, there are alternatives to represent collections of associations in Lisp. (e.g., Hash tables)
CSE (c) S. Tanimoto, Lisp Data Structures

3. Direct Manipulation of Conses
> (setq x (cons 'a 'b))
(A . B)
> (rplaca x 'c)
(C . B)
> x
> (rplacd x 'd)
(C . D)
> (rplacd x x)
(C C C C C C C C C C ... )
>
CSE (c) S. Tanimoto, Lisp Data Structures

4. CSE 415 -- (c) S. Tanimoto, 2002 Lisp Data Structures
Adjacency Lists
Nowadays, RPLACA and RPLACD are less used.
Straight lists are more common.
Memory space is less of a concern.
(setq nodes '(a b c d))
(setq arc-lists '(
(a (b c))
(b (d))
(c (d))
(d ())
) )
(defun is-edge (x y)
(member y (second (assoc x arc-lists))) )
(is-edge 'a 'c) ; => (C) i.e., true.
(is-edge 'a 'd) ; => NIL A C B D
CSE (c) S. Tanimoto, Lisp Data Structures

5. CSE 415 -- (c) S. Tanimoto, 2002 Lisp Data Structures
Sequences
A sequence can be thought of as a mapping from
{0, 1, ..., n-1} to a set of range elements.
A string is a sequence of characters.
A list is a particular form of sequence of lisp objects.
(typep "abc" 'sequence) ; => T.
(typep '(a b c) 'sequence) ; => T.
(concatenate 'string "abc" "def"); => "abcdef"
(concatenate 'list '(a b) '(c d)); =>(a b c d)
(elt '(a b c d) 2) ;=> C
CSE (c) S. Tanimoto, Lisp Data Structures

6. CSE 415 -- (c) S. Tanimoto, 2002 Lisp Data Structures
Arrays
An array is a mapping from a set of index tuples to a set of range elements.
(setq a (make-array '(5 10):initial-element 1))
#2A(( )
( )
( ))
(setf (aref a 4 9) 2) 2
(let ((sum 0))
(dotimes (i 5 sum)(dotimes (j 10)
(incf sum (aref a i j)) )) ) 51
CSE (c) S. Tanimoto, Lisp Data Structures

7. CSE 415 -- (c) S. Tanimoto, 2002 Lisp Data Structures
Hashtables
Association lists are linear and slow. For larger sets of associations, hashtables tend to be much faster.
> (let ((h (make-hash-table)))
(defun get-h (key) (gethash key h))
(defun put-h (key value)
(setf (gethash key h) value)) )
PUT-H
> (put-h 'x 'y) Y
> (get-h 'x)
Y ; The value associated with X
T ; True, there is a value.
>
CSE (c) S. Tanimoto, Lisp Data Structures

8. CSE 415 -- (c) S. Tanimoto, 2002 Lisp Data Structures
MAPHASH
; Changes each entry in THE-HASH-TABLE,
; replacing each positive value with its
; square root, and removing negative values.
(maphash ; Steele’84, p285.
#'(lambda (key value)
(if (minusp value)
(remhash key the-hash-table)
(setf (gethash key the-hash-table)
(sqrt value))))
the-hash-table)
; returns NIL
CSE (c) S. Tanimoto, Lisp Data Structures

9. CSE 415 -- (c) S. Tanimoto, 2002 Lisp Data Structures
Strings
A Lisp string is written as a sequence of characters between double quotes.
"This is a string."
Double quotes can be entered using the backslash character
"Here is a \"string within a string\"."
Backslashes can be included by using a double backslash:
"c:\\windows\\system\\temp.txt"
A string is a one-dimensional array of characters.
CSE (c) S. Tanimoto, Lisp Data Structures

10. CSE 415 -- (c) S. Tanimoto, 2002 Lisp Data Structures
Constructing Strings
Concatenation
> (concatenate 'string "Happy" " " "Birthday!")
"Happy Birthday!"
Character-by-character manipulation
> (setq str (make-string 5 :initial-element #\A))
"AAAAA"
> (setf (aref str 2 #\C))
#\C
> str
"AACAA"
CSE (c) S. Tanimoto, Lisp Data Structures

11. CSE 415 -- (c) S. Tanimoto, 2002 Lisp Data Structures
Comparing Strings
> (string= "happy" "happy") T
> (string= "hapPy" "happy")
NIL
> (string/= "hapPy" "happy") 3
> (string-equal "hapPy" "happy")
> (string-lessp "John" "johnny") 4
> (string< "John" "johnny")
> (equal "hapPy" "happy")
> (equalp "hapPy" "happy")
CSE (c) S. Tanimoto, Lisp Data Structures

12. String Input and Output
> (setq line (read-line))This is a line of text.
"This is a line of text."
> (print line)
> (format t "The input was: ~S" line)
The input was: "This is a line of text."
NIL
> (format t "The input was: ~A" line)
The input was: This is a line of text.
> (setq line2
(format nil (format t "The input was: ~A" line)))
"The input was: This is a line of text."
CSE (c) S. Tanimoto, Lisp Data Structures

13. CSE 415 -- (c) S. Tanimoto, 2002 Lisp Data Structures
String Matching
> (search "line" "This is a line of text.") 10
> (search "line" "THIS IS A LINE OF TEXT.")
NIL
> (search "line" "THIS IS A LINE OF TEXT."
:test #'char-equal)
> (search "xy9" "abcde01234" :key #'digit-char-p) 3
; SEARCH works not only on strings but all sequences.
> (search '(0 1) '( )) 2
> (search '(0 1) '( ) :key #'evenp)
CSE (c) S. Tanimoto, Lisp Data Structures

14. CSE 415 -- (c) S. Tanimoto, 2002 Lisp Data Structures
Substring Extraction
> (subseq "This is a line of text." 10 14)
"line"
> (subseq "The remainder of the line." 4)
"remainder of the line."
> (setf (subseq "Let’s censor it." 6 12)
"XYZXYZXYZW")
"Let’s XYZXYZ it."
CSE (c) S. Tanimoto, Lisp Data Structures