;; Symbolic Data
;;
;; File:	symbolic-data.lsp
;; Version:	2
;; Author:	walton@das.harvard.edu

;; Computer Representation of Lists

'(a b)
--->
(A B)

'(a . (b))
--->
(A B)

'(a . (b . ()))
--->
(A B)

'(a . (b . nil))
--->
(A B)

'(5 . ((a . (b . nil)) . (7 . nil)))
--->
(5 (A B) 7)

'(a . (b . c))
--->
(A B . C)



;; Use of Quote (')

(* 2 5)
--->
10

'(* 2 5)
--->
(* 2 5)

;; `m' without a quote gives an error
;;
m
--->
ERROR: EVAL: variable M has no value
NIL

'm
--->
M

'hi-there
--->
HI-THERE

'Hi-ThErE
--->
HI-THERE

'5
--->
5

5
--->
5



'nil
--->
NIL

nil
--->
NIL

't
--->
T

t
--->
T

''x
--->
'X

'(quote x)
--->
'X

''(a 'b c)
--->
'(A 'B C)

'(quote (a (quote b) c))
--->
'(A 'B C)



;; Manipulation of List Data

(cons 'a '(b c))
--->
(A B C)

(car '(a b c))
--->
A

(first '(a b c))
--->
A

(cdr '(a b c))
--->
(B C)

(rest '(a b c))
--->
(B C)

(cons 'a nil)
--->
(A)


;; NTH

;; (my-nth 0 'x) ===> (car 'x)
;; (my-nth n 'x) ===> (my-nth (- n 1) (cdr 'x))
;;                    if n > 0
;;
;; where n is an integer,  x is an s-expression
;;
(defun my-nth (n x)
  (cond
   ((= n 0) (car x))
   ((> n 0) (my-nth (- n 1) (cdr x)))))
--->
MY-NTH

(my-nth 0 '(a b c))
--->
A

(my-nth 1 '(a b c))
--->
B

(my-nth 2 '(a b c))
--->
C

(my-nth 3 '(a b c))
--->
NIL

;; (my-nth -1 '(a b c)) would loop `forever'

;; The following is in error:
;;
(my-nth 'a '(a b c))
--->
ERROR: argument to = should be a number: A
NIL


;; APPEND

;; (my-append '() 'z) ===> 'z
;; (my-append '(x . y) 'z) ===>
;;	(cons 'x (my-append 'y 'z))
;;
;; where x, y, z are s-expressions
;;
(defun my-append (w z)
  (cond
   ((null w) z)
   (t (cons (car w) (my-append (cdr w) z)))))
--->
MY-APPEND

(my-append '() '(1 2))
--->
(1 2)

(my-append '(a) '(1 2))
--->
(A 1 2)

(my-append '(a b) '(1 2))
--->
(A B 1 2)

(my-append '(a b) '(1))
--->
(A B 1)

(my-append '(a b) '())
--->
(A B)




; REVERSE

;; (my-reverse 'x)  ===> (my-reverse 'x '())
;; (my-reverse '() 'z) ===> 'z
;; (my-reverse '(x . y) 'z) ===>
;;	(my-reverse 'y '(x . z))
;;
;; where x, y, z are s-expressions
;;
(defun my-reverse (w &optional (z nil))
  (cond
   ((null w) z)
   (t (my-reverse (cdr w) (cons (car w) z)))))
--->
MY-REVERSE

(my-reverse '(a b) '(1 2))
--->
(B A 1 2)

(my-reverse '(a b c d) nil)
--->
(D C B A)

(my-reverse '(a b c d))
--->
(D C B A)



;; Symbolic Predicates

(consp 'a)
--->
NIL

(consp '(1 . 2))
--->
T

(eql 'a 'a)
--->
T

(eql 'a 'b)
--->
NIL

(eql 5 5)
--->
T

(eql 5 6)
--->
NIL

(eql 5 5.0)
--->
NIL

(eql 'a '(a . b))
--->
NIL

(eql '(a . b) 'a)
--->
NIL


(symbolp 'a)
--->
T

(symbolp '(a b))
--->
NIL

(symbolp '())
--->
T

(symbolp 5)
--->
NIL

(numberp '5a)
--->
NIL

(numberp '5)
--->
T

(atom 'a)
--->
T

(atom '(1 . 2))
--->
NIL

(atom nil)
--->
T

(atom '())
--->
T


(null nil)
--->
T

(null '())
--->
T

(null '(a . b))
--->
NIL

(null 'a)
--->
NIL

(listp '())
--->
T

(listp nil)
--->
T

(listp '(a . b))
--->
T

(listp 'a)
--->
NIL



;; MEMBER

;; (my-member 'x '()) ===> nil
;; (my-member 'x  '(y . z))
;;	===> '(y . z)      	    if (eql 'x 'y)
;;      ===> (my-member 'x 'z)      otherwise
;;
;; where x, y, z are s-expressions
;;
(defun my-member (x w)
  (cond
   ((null w) nil)
   ((eql x (car w)) w)
   (t (my-member x (cdr w)))))
--->
MY-MEMBER

(my-member 'a '(a b c))
--->
(A B C)

(my-member 'b '(a b c))
--->
(B C)

(my-member 'c '(a b c))
--->
(C)

(my-member 'x '(a b c))
--->
NIL



;; EQUAL

;; (my-equal 'u 'v) ===> (eql 'u 'v)  if either u or v
;;					 is an atom
;; (my-equal '(w . x) '(y . z)) ===>
;;	(and (equal 'w 'y) (equal 'x 'z))    otherwise
;;
;; where u, v, w, x, y, z are s-expressions
;;
(defun my-equal (u v)
  (cond
   ((or (atom u) (atom v))
    (eql u v))
   (t
    (and (my-equal (car u) (car v))
	 (my-equal (cdr u) (cdr v))))))
--->
MY-EQUAL

(my-equal 'a 'a)
--->
T

(my-equal '(a b) '(a b))
--->
T

(my-equal '(a (b c) 5) '(a (b c) 5))
--->
T

(my-equal '(a (b c) 5) '(a (b x) 5))
--->
NIL



;; LET*

(let* ((x 'a)
       (y 'a))
  (eql x y))
--->
T

(let* ((x (cons 'a nil))
       (y (cons 'a nil)))
  (eql x y))
--->
NIL



;; EQL

(let* ((x 5)
       (y (cons 5 nil))
       (z (cons y (cons x nil))))
    (eql x 5))
--->
T

(let* ((x 5)
       (y (cons 5 nil))
       (z (cons y (cons x nil))))
    (eql x (car y)))
--->
T

(let* ((x 5)
       (y (cons 5 nil))
       (z (cons y (cons x nil))))
    (eql x (cdr y)))
--->
NIL

(let* ((x 5)
       (y (cons 5 nil))
       (z (cons y (cons x nil))))
    (eql x (car z)))
--->
NIL

(let* ((x 5)
       (y (cons 5 nil))
       (z (cons y (cons x nil))))
    (eql x (cdr z)))
--->
NIL



(let* ((x 5)
       (y (cons 5 nil))
       (z (cons y (cons x nil))))
    (eql x (car (car z))))
--->
T

(let* ((x 5)
       (y (cons 5 nil))
       (z (cons y (cons x nil))))
    (eql x (car (cdr z))))
--->
T

(let* ((x 5)
       (y (cons 5 nil))
       (z (cons y (cons x nil))))
    (eql y (car z)))
--->
T

(let* ((x 5)
       (y (cons 5 nil))
       (z (cons y (cons x nil))))
    (eql y (car (car z))))
--->
NIL

(let* ((x 5)
       (y (cons 5 nil))
       (z (cons y (cons x nil))))
    (eql y (car (cdr z))))
--->
NIL