To convoniently create one-dimensional array, we use vector:

;; A simple vector is a simple array of one dimension that can contain elements of any type.
(vector 1 "zw" 'b)
(setf myvec (vector 1 2 3))
;; access vector element
(aref myvec 1)
(svref myvec 0) ; faster

• It consistutes the type vector which is a subtype of array.
  
• While it takes O(1) to access element in vector, it takes O(n) to add a new element to the front of a vector.
  
• To create vector that could be extended, we must use array construct. See dynamic array.
  

;; Create dynamic array: 
(setf myarray (make-array 0 :fill-pointer 0 :adjustable t)) ; created a one dimentional array with size 0
(vector-push-extend 100 myarray)
(vector-push-extend 101 myarray)
myarray

• adjustable make our array’s capacity increase if it is enough.
  
• The fill pointer is a non-negative integer no larger than the total number of elements in the vector (as returned by array-dimension); it is the number of ``active’’ or ``filled-in’’ elements in the vector.
  
• Only vectors (one-dimensional arrays) may have fill pointers.
  

Sequence is include both list and one-dimensional array(vector).

(setf myarr (make-array 0 :adjustable t :fill-pointer 0))
(dotimes (i 5)
  (vector-push-extend i myarr))

(setf myvec (vector 0 1 2 3 4))
(setf mylst (list 0 1 2 3 4))

myarr
myvec
mylst

(length myarr)
(length myvec)
(length mylst)

(reverse myarr)
(reverse myvec)
(reverse mylst)

(setf myarr02 (subseq myarr 3))
myarr02
myarr ; not changed

;; setf with subset to replace subseq in sequence
(setf (subseq myvec 3 5) #(-1 -2 -3 -4 -5))
myvec ; => #(0 1 2 -1 -2) notice the additional values are cut off.

• Strings are vectors of characters.
  
• Because strings are vectors, both sequence functions and array functions work on them.
  
• A single char ’x’ is denoted as #\x.
  

• Examples
  

  ;; build string
  ;; 1) the most general way is to use format
  (setf str (format nil "~A or ~A" "true" "false"))
  ;; 2) join several strings together
  (setf str01 (concatenate 'string str " is not a question"))
  
  ;; a function which get the second word from a sentence
  (defun second-word (str)
    (let ((p1 (+ (position #\  str) 1)))
      (if (char= #\ (char str p1)) ; char is faster than aref for string 
          (second-word (subseq str (1+ p1)))
          (subseq str p1 (position #\  str :start p1)))))
  (second-word "one   two  tree.")
  

  • char
    
  • char=
    
  • position
    

1. create hashtable, create key and values
   

   ;; How to create an empty map?
   (let ((ht (make-hash-table)))
     (multiple-value-bind (val ok) (gethash "zw" ht)
       (if (not ok)
           (format t "no record~%")
           (format t "val: ~A~%" val))))
   
   ;; How to add element into map?
   (let ((ht (make-hash-table)))
     (setf (gethash 'zw ht) "pdbh")
     (multiple-value-bind (val ok) (gethash 'zw ht)
       (if (not ok)
           (format t "no record~%")
           (format t "val: ~A~%" val))))
   
   ;; use :test to specify equality test function, by defaut it is "eql"
   (let ((ht (make-hash-table :test #'equal)))
     (setf (gethash "zw" ht) "pdbh")
     (multiple-value-bind (val ok) (gethash "zw" ht)
       (if (not ok)
           (format t "no record~%")
           (format t "val: ~A~%" val))))
   
   ;; How to decide if a key is valid in map?
   

2. Remove member from hashtable
   

   (let ((ht (make-hash-table)))
     (setf (gethash 'zw ht) "pdbh")
     (format t "key: ~A, value: ~A~%" 'zw (gethash 'zw ht))
     (remhash 'zw ht)
     (format t "key: ~A, value: ~A~%" 'zw (gethash 'zw ht)))
   

3. Loop through hashtable
   

   (let ((ht (make-hash-table)))
     (setf (gethash 1 ht) "pdbh")
     (setf (gethash 2 ht) "wei")
     (setf (gethash 3 ht) "fox")
   
     (maphash #'(lambda (k v)
                  (format t "~A = ~A~%" k v))
              ht)
   
     (terpri)
     (let ((keys ()))
       (maphash #'(lambda (k v)
                    (format t "~A = ~A~%" k v)
                    ;; (setf keys (cons k keys))
                    (push k keys))
                ht)
       (format t "~A~%" keys)
       (setf keys (sort keys #'>))
       (format t "~A~%" keys)
       (terpri)
   
       (mapcar #'(lambda (x)
                   (format t "~A = ~A~%" x (gethash x ht)))
               keys)))
   
   ;; sort hashtable
   ;; 1) collect keys
   (sort '(2 1 3) #'<)
   ;; 2) loop through keys and retrieve value 
   

1. A basic example
   

   (defstruct point
     x
     y) ; type order:  point -> structure -> atom -> t
   
   (setf p (make-point :x 0 :y 0)) ; make-point 
   (point-x p) ;access function
   
   (point-p p) ; using point-p to test whether something is a point
   (typep p 'point) ; using general-purpose function to test its type
   

   • By default, the default value is NIL.
     

2. specify default values for structure field
   

   (defstruct polemic
     (type (progn
             (format t "what kind of polemic was it?")
             (read)))
     (effect nil))
   

3. control how a structure is displayed and the prefix used in the name of the access function it creates
   

   (defstruct (point (:conc-name p)
                     (:print-function print-point))
     (x 0)
     (y 0))
   
   ;; for print-function, the third argument could be ignored for most of time
   (defun print-point (p stream depth)
     (format stream "#<~A, ~A>" (px p) (py p)))
   (setf p (make-point))
   

   • We specify the default value.
     
   • We specify the access-prefix.
     
   • We specify the print-function which must takes 3 argument.
     
4. Related questions
   
   • How to create custom struct with zero value as simple as possible?
     
     • The default value is NIL.
       
     • We could specify the inital value when defstruct.
       
   • How to access struct’s attributes
     
     • defstruct create accessor functions automatically.
       
     • By default, it is the xxx-yy format, where xxx is the struct name, and yy is the attribute name.
       

• Suppose we have a file called playground.lisp.
  

  (defun main ()
    (print 'hello-world))
  

• Execute main function as
  

  sbcl --noinform --load playground --eval '(progn (main) (sb-ext:quit))'
  

• eq return true only if two object are implementationnally identical.
  
• eql is the same as eq, except that if the arguments are characters or numbers or numbers of the same type then their values are compared. It is the default comparision predicate when need equality check in common-lisp code (such :test).
  
• equal, The equal predicate is true if its arguments are structurally similar (isomorphic) objects. A rough rule of thumb is that two objects are equal if and only if their printed representations are the same.
  
• equalp return true if its argument would print the same with. case-insensitive
  
• Some cases
  

  1. numbers
     

     (eql 5.0 5)
     

     (equal 5 5.0)
     

     (equalp 5 5.0)
     

     (= 5 5.0)
     

  2. List, String and Vector
     

     ;; list 
     (let ((l1 (list 1 2 3))
           (l2 (list 1 2 3)))
       (format t "l1 is l2: ~A~%" (eql l1 l2)) ; nil 
       (format t "l1 has same content as l2: ~A~%" (equal l1 l2)) ; t
       (format t "l1 has same content as l2: ~A~%" (equalp l1 l2))) ; t
     
     ;; string 
     (let ((s1 "abc")
           (s2 "ABC"))
       (format t "s1 is s2: ~A~%" (eql s1 s2)) ; nil 
       (format t "s1 has same content as s2: ~A~%" (equal s1 s2)) ; nil 
       (format t "s1 has same content as s2: ~A~%" (equalp s1 s2))) ; t
     
     ;; we have to use equalp to compare contents for list and array
     (let ((arr1 (make-array 3 :initial-contents (list 1 2 3)))
           (arr2 (make-array 3 :initial-contents (list 1 2 3))))
       (format t "arr1 is arr2: ~A~%" (eql arr1 arr2)) ; nil 
       (format t "arr1 has same content as arr2: ~A~%" (equal arr1 arr2)) ; nil 
       (format t "arr1 has same content as arr2: ~A~%" (equalp arr1 arr2))) ; t
     
     (let ((v1 (vector 1 2 3))
           (v2 (vector 1 2 3)))
       (format t "v1 is v2: ~A~%" (eql v1 v2)) ; nil
       (format t "v1 has same content as v2: ~A~%" (equal v1 v2)) ; nil 
       (format t "v1 has same content as v2: ~A~%" (equalp v1 v2))) ; t
     

1. process string one character a time (loop over string)
   

   (loop for c across "abcd"
         collect c)
   (loop for c in (coerce "abcd" 'list)
         collect c)
   

(setf lst '(1 2 3))
(cons 0 lst)

• Use cons to add new element to the head of a list.
  

(setf lst '(1 2 3))
(setf lst1 (append lst '(100 101)))
(setf lst2 (append '(100 101) lst))

(setf (nth 2 lst2) 1000)
lst2
lst1

(append '(1 2 3) '(4 5 6) '(7 8 9))

• append creates copy of sequence.
  

(setf vec #(1 2 3))

(concatenate 'vector vec (vector 100 101))
(concatenate 'vector (vector 100 101) vec)

• We can think of concatenate as a general append for sequence.
  

(concatenate 'list '(1 2) (vector 3 4 5))

(concatenate 'vector '(a b) #(c d e))
(concatenate 'vector '(a b) (vector 'c 'd 'e) #(f g))

(concatenate 'string "hello" " " "world")

• The type must be one of these three types: list, vector and string (not including array).
  

1. subseq creates copy of sequence
   

   (setf myvec #(a b c d e f))
   (concatenate 'vector (subseq myvec 3) (vector 1 2 3))
   
   ;; Here, we create a slice from myvec set it to myseq
   (setf myseq (subseq myvec 4))
   
   (setf (aref myseq 1) "100")
   myseq
   myvec
   

   • Remember sequence includes vector(one-dimensional array) and list.
     
   • subseq creates copy. We modify the myseq, and the its original vector doesn’t change
     

2. In case we want to achieve the same passager for different buses effect:
   

   (ql:quickload :rutils)
   
   (setf myvec #(a b c d e f))
   (setf mypart (rtl:slice myvec 4))
   (setf (aref mypart 1) "100")
   mypart
   myvec
   

   • rtl:slice (from rutils package) create “same passager in different bus”.
     

(defun copy-array (arr)
  (setf result-array (subseq arr 0)))
(let ((vec (vector 1 2 3 4 5)))
  (setf cp-vec (copy-array vec))
  cp-vec)

• Use subseq.
  

;;;; Dynamic Vectors
(defun map-vec (fn vec)
  (let ((result-vec (make-array (length vec))))
    (dotimes (i (length vec))
      (setf (aref result-vec i) (funcall fn (aref vec i))))
    result-vec))

(defun map-vec (fn vec)
  (let ((result-vec (make-array (length vec))))
    (dotimes (i (length vec))
      (setf (aref result-vec i) (apply fn (list (aref vec i)))))
    result-vec))

;; use build-in map
(defun map-vec (fn vec)
  (let ((result-vec (map 'vector fn vec)))
    result-vec))

• Notice that apply vs funcall: apply needs the arguments to be a list.