Laborator LISP Nr. 2

Atribuire, variabile globale, constante


[1]> (defvar y 1)
Y

[2]> (defvar z 2 "O variabila foarte utila")
Z

[3]> (+ y z)
3

[4]> (defvar *nume-traditional* nil "Aceasta variabila are un nume traditional")
*NUME-TRADITIONAL*

[5]> (defvar *minim* (min y z))
*MINIM*

[6]> *minim*
1

[7]> (defparameter v "valoare obligatorie")
V

[8]> (defvar v 2)
V

[9]> v
"valoare obligatorie"

[10]> (defvar g 6)
G

[11]> (defparameter g 7)
G

[12]> g
7

[13]> (defconstant *pi* 3.14159265358979323)
*PI*

[14]> (defconstant *pi* 1)

WARNING:
(DEFCONSTANT *PI* 1) redefines the constant *PI*. Its old value was 3.1415927.
*PI*

[15]> *pi*
1

[16]> (setq x (+ 3 2 1) y (cons x nil))
(6)

[17]> (setq)
NIL

[18]> (setq a 1)
1

[19]> (setq b 2)
2

[20]> (psetq a b b a)
NIL

[21]> a
2

[22]> b
1

Observații:

Egalitatea - o chestiune netrivială în LISP

Common Lisp oferă mai multe predicate pentru testarea egalității a două obiecte.
Acestea sunt, în ordinea specificității: eq (cel mai restrictiv/specific), eql, equal, and equalp (cel mai general).
[1]> (eq 'a 'b)
NIL

[2]> (eq 'a 'a)
T

[3]> (eq 1 1) -----> depinde de implementare!
T

[4]> (eq "abc" "abc") -----> depinde de implementare!
NIL

[5]> (eq 3 3.0)
NIL

[6]> (eq "Test" "test")
NIL

[7]> (eq (cons 'a 'b) (cons 'a 'c))
NIL

[8]> (eq (cons 'a 'b) (cons 'a 'b))
NIL

[9]> (eq '(a . b) '(a . b)) -----> depinde de implementare!
NIL

[10]> (setq x 1)
1

[11]> (setq y 1)
1

[12]> (eql x y)
T

[13]> (eql '(1 2 3) '(1 2 3))
NIL

[14]> (eql "abc" "abc")
NIL

[15]> (equal '(1 2 3 . 4) '(1 2 3 . 4))
T

[16]> (equal #\a #\a)
T

[17]> (equal #\a #\A)
NIL

[18]> (equalp 'a 'b)
NIL

[19]> (equalp 'a 'a)
T

[20]> (equalp 3 3)
T

[21]> (equalp 3 3.0)
T

[22]> (equalp "AbC" "abc")
T

[23]> (equalp '("AbC" 1 2) '("abc" 1 2))
T

Observații:

Lista vidă - atom și listă în același timp


[1]> (atom 'a)
T

[2]> (atom '(1 2 3))
NIL

[3]> (listp '(1 2 3))
T

[4]> (listp 'a)
NIL

[5]> (atom nil)
T

[6]> (listp nil)
T

[7]> (listp '())
T

[8]> (listp ())
T

Observații:

"<", ">" și "="


[1]> (> 4 3 2 1)
T

[2]> (> 4 3 2 5)
NIL

[3]> (> 4 3 2 2)
NIL

[4]> (>= 4 3 2 2)
T

[5]> (= 2 2.0)          
T

if și cond - adevărat și fals


[1]> (if (> 3 2) (+ 4 5) (* 3 7))
9

[2]> (if (< 3 2) (+ 4 5) (* 3 7))
21

[3]> (if (+ 2 3) 1 2)
1

[4]> (equalp (+ 2 3) t)
NIL

[5]> (if nil 1 2)
2

[6]> (cond ((= 2 3) 1) ((< 2 3) 2))
2

[7]> (cond ((= 2 3) 1) ((> 2 3) 2) (t 3))
3

[8]> (cond ((= 2 3) 1) ((> 2 3) 2) (3))
3

[9]> (cond ((= 2 2) (print 1) 8) ((> 2 3) 2) (t 3))

1 
8

Observații:

Recursivitate - un prim contact


(defun our-expt (m n)
  (cond ((zerop n) 1)
        (t (* m (our-expt m (- n 1))))
  )
)

(defun fibonacci (n)
  (cond ((= n 0) 0)
        ((= n 1) 1)
        (t (+ (fibonacci (- n 1))
              (fibonacci (- n 2))
           )
        )
  )
)

(defun count-atoms (l)
  (cond ((null l) 0)
        ((atom l) 1)
        (t (+ (count-atoms (car l))
              (count-atoms (cdr l))
           )
        )
  )
)

Observații: