Arrays in Lisp

• An array is a sequence of contiguous memory locations in which we can store objects of any kind.
• There are four types of arrays in Elisp: strings, vectors, bool-vectors, and char-tables.
• They are indexed starting from 0. In lisp they are 1-dimensional.
• Both lists and arrays are sequences.

Array Functions

• Constant arrays:
  (setq a '[1 2 3 45 65]) ; [1 2 3 45 65]
• Using the functions vector and make-vector:
  (setq b (vector 'a 32 nil '(1 2 3)))
  ; [a 32 nil (1 2 3)]
  (setq sleepy (make-vector 5 'Z));[Z Z Z Z Z]
• Concatenating vectors:
  (vconcat [A B C] "aa" '(foo (6 7)))
  ; [A B C 97 97 foo (6 7)]
• Accessing / modifying an element of an array:
  (elt a 3) ; 45
  (aset b 2 'monday) ; [a 32 monday (1 2 3)]
• Array size: (length '[1 2 3 4]) returns 4.

Symbols

• A symbol has 4 attributes (cells):
• print name - to be called by symbol-name, its name for printing
• value cell - contains its value as a variable, symbol-value
• function cell - the function definition, symbol-function
• property list cell - its meaning as a property list, symbol-plist.
• Symbols can exist in the program without any of these cells being defined. 'a is interpreted as the symbol a even if it's not defined as a function or variable. Symbols are unique.

Examples of Symbols

(make-symbol "wolf") ;=> wolf
(symbol-name 'wolf)  ;=> "wolf"
(setq dog (make-symbol "dog")) ;=> dog
(symbol-name dog) ;=> "dog"
(symbol-name 'dog) ;=> "dog"
(setq goat "fluffy") ;=> "fluffy"
goat ;=> "fluffy"
(symbol-name 'goat) ;=> "goat"
(symbol-value 'goat) ;=>"fluffy"

Equality Predicates

• There are 3 predicates that test the equality of objects in Elisp.
• = - tests if two numbers are equal. Returns an error if one of the arguments is not a number.
• eq - tests if the two arguments are identical objects in the memory.
• equal - tests if the two arguments have similar content. If the objects are containers (lists, arrays), it compares the size and the corresponding elements.

Examples

(setq L '(1 2 3 4))  ;=>  (1 2 3 4)
(setq M '(1 2 3 4))  ;=>  (1 2 3 4)
(eq L M)  ;=>  nil
(equal L M) ;=>  t
(setq M L)  ;=>  (1 2 3 4)
(eq L M)  ;=>  t
(eq '(1 2 3) '(1 2 3))  ;=>  nil
(eq "hello world" "hello world") ;=> nil
(eq 1 1) ;=> t
(eq 1 1) ;=> t
(eq 'L 'L) ;=> t
(setq M 'L) ;=> L
(eq 'L M) ;=> t

Associative Lists

• A list where the elements are pairs of keys associated with values.
  (setq flowers '((rose . red) (lily . white) (iris . purple)))
• It makes it easy to find values associated with the keys:
  (assoc 'lily flowers ) ;=> (lily . white)
  (rassoc 'purple flowers ) ;=> (iris . purple)
  
• assq, rassq - same as assoc and rassoc but use eq instead of equal.
• copy-alist - a 2-level deep copy of the list.

Example

(setq A '((jan . 31) (feb . 28) (mar . 31) (feb . 29) (apr . 31) (may . 30)))
;((jan . 31) (feb . 28) (mar . 31) (feb . 29) (apr . 31) (may . 30))
(assoc 'feb A) ; (feb . 28)
(rassoc 29 A) ; (feb . 29)
(rassoc 31 A) ; (jan . 31)
(assq 'mar A) ; (mar . 31)
(setq M 'mar) ; mar
(assq M A) ; (mar . 31)

Some Functions

(defun copyalist (L)
  "Copies an associative list."
  (let ((newlist ()))
    (dolist (e L newlist)
      (setq newlist
        (append newlist
          (list (cons (car e)
                      (cdr e) 
          )))))))
(defun setassoc (sym val L)
  "Associates the value with the symbol in the list L."
  (setcdr (assoc sym L) val))

(setq B (copyalist A))
; ((jan . 31) (feb . 28) (mar . 31) (feb . 29) (apr . 31) (may . 30))

(setcdr (assoc 'jan B) 32) ; 32
B ; ((jan . 32) (feb . 28) (mar . 31) (feb . 29) (apr . 31) (may . 30))
A ; ((jan . 31) (feb . 28) (mar . 31) (feb . 29) (apr . 31) (may . 30))

(setassoc 'apr 30 B) ; 30
B ; ((jan . 32) (feb . 28) (mar . 31) (feb . 29) (apr . 30) (may . 30))
A ; ((jan . 31) (feb . 28) (mar . 31) (feb . 29) (apr . 31) (may . 30))

catch-throw

• An organized way to break out of structures, especially loops.
• Somewhat similar to goto. Also similar to error & exception catching and throwing.
• A catch used with a tag is wrapper around a structure. It is a return point for when the tag is generated by a throw inside the structure.
• If no throw happens, then the catch works like a progn.
• The throw provides a return value too.

Syntax

(catch tag
  block of expressions) 

• The tag can be any value except for nil.
• If no tag is thrown, then the catch returns whatever the block of expressions returns normally.
• If the tag is thrown, then the value it provides is returned from the catch.

Example 1

; returns 0 if n is 0, 1 if n is positive, -1 if n is negative
(defun sign (n)
  (catch 'negative
    (catch 'zero
      (cond
       ((= n 0) (throw 'zero 0))
       ((< n 0) (throw 'negative -1))
       (t 1)))))

(sign 0) ; 0
(sign 3) ; 1
(sign -5); -1

Example 2

; searches for the value val in the list L. returns t if the value is present,
; nil if the value is not in the list.
(defun search (L val)
  (if (not L) nil ; an empty list does not contain the value
    (catch 'found ; prepare a place to return to when we find val
      (dolist (elem L nil)   ; if the loop terminates without a throw
        (if (equal elem val) ; then the value is not in it
            (throw 'found t)))))) ; exits the loop

(search	'(1 2 3 4 5) 3) ; t
(search	'(1 2 3 4 5) 8) ; nil

Example 3

; returns t if the list L is sorted, nil if it isn't.
(defun is-sorted (L)
  (if (not (cdr	L)) t ; if the list has 0 or 1 elements, it is sorted
    (let ((prev (car L))) 
      (catch 'notsorted ; return point from the throw
        (dolist (elem (cdr L) t)
          (if (> prev elem)
              (throw 'notsorted	nil)
            (setq prev elem)))))))

(is-sorted '(1 2 3 4 5 6)) ; t
(is-sorted '(2 3 4 1 2 4)) ; nil