Lecture 1

Question 1

What is an atom?

Answer 1

letters, digits, *, -, , etc.

Question 2

What is a List?

Answer 2

(1 2 3 4), (a (b c) (d (e f))) (sequence of atoms/lists)

Question 3

what represents false in LISP?

Answer 3

nil and ()

Question 4

what is an s-expression?

Answer 4

1. an atom is an s-sxpression

2. if s⌄1, s⌄2, s⌄3, … s⌄n are s-expressions then so is the list (s⌄1 s⌄2 s⌄3)

Question 5

how are s-expression lists evaluated?

Answer 5

first elements is function name and the others are arguments

Question 6

how are number, lists and atomic symbols evaluated?

Answer 6

numbers - evaluated as numbers
atomic symbols - return value bound (error if nothing is bound)
list - evaluate second to last and apply the first element as function

Question 7

write a function that squares a number

Answer 7

(defun square (x)

(* x x))

Question 8

explain defun arguments

Answer 8

first argument is name, second is a list of arguments passed in, third is the function itself (body)

Question 9

explain cond keyword

Answer 9

(cond (()())
(()()))
cond goes until non-nil value is found, if non is found returns nil

Question 10

how do we make a default action in cond statement?

Answer 10

last argument in cond should be (t x)
t - always true
x - default action

Question 11

describe if statement

Answer 11

(if (

Question 12

explain when and unless in terms of if statements

Answer 12

when and unless both return nil in else case
when - 1st arg is true preform second
unless - 1st arg is false preform secnd

Question 13

what is a predicate?

Answer 13

function that returns true or false

Question 14

when does lisp return nil?

Answer 14

to indicate false, t is used for EVERYTHING else

Question 15

explain and and or functions in lisp

Answer 15

and - everything has to be t, or result is nil. If everything is true last expression is returned.

or - evaluates until non-nil is found.

Question 16

what does not do?

Answer 16

not takes and argument and returns the opposite

Question 17

what does list argument do?

Answer 17

takes and number of arguments and returns a list of those arguments

Question 18

what does cdr, car and cons do?

Answer 18

cdr - takes list and returns list with first element removed
car - 1 arg returns first element in list
cons - 2 args, returns list with first argument at start of list

Question 19

what does append, nth and length do in lisp?

Answer 19

append - 2 args, combines them.
nth - 2 args (# and list), returns element at #
length - 1 arg, returns # of elements in list

Question 20

what does member, null and listp mean?

Answer 20

member - 2 args, tries to find element in second arg. eg (member 2 (1 2 3 4)) = (2 3 4)
null - 1 arg, returns t if list is empty
listp - 1 arg, returns true if arg is list

Question 21

what does atom do?

Answer 21

1 arg returns true if arg is atom. (atom (list 1 2 3 4)) = nil, (atom ()) = true

Question 22

explain quote, add it to (nth 0 (a b c d))

Answer 22

this doesn’t work because a isnt a function so fails. (nth 0 quote(a b c d)) = does work, so does (nth 0 ‘(a b c d)). quote returns arg without evaluating

Question 23

what does eval do?

Answer 23

eval forces evaluation on something (opposite of quote)

Question 24

how do i initiate a variable?

Answer 24

setf - 2 args, binds second to first (setf x ‘(a b c))

Question 25

explain setf and defparameter? what does a change to defparameter mean?

Answer 25

setf- binds variables defparameter - global variables *variable-name* change to defparameter is considered a change to the program not a change by the program

Question 26

explain let

Answer 26

for local variables eg (defun (x y) (let ((a x) (b (* x y))))) makes a = x and b = x*y and are local variables

Question 27

what does let* allow?

Answer 27

let* allows local variables to be used to initiate other variables eg. (let* ((a 2) (b (* a a)))), b is initiated with a * a

Question 28

write recursive factorial that takes 1 arg

Answer 28

(defun factrl (n) (cond ((= n 0) 1) (t (* n (factrl (- n 1))))))

Question 29

Explain scanning through a list recursivley (sum of #'s)

Answer 29

``` (defun sum (list) (cond ((null list) 0) (t (+ (first list) (sum (rest list)))))) first = car, rest = cdr ```

Question 30

what is a first class object?

Answer 30

``` named by a symbol, passed as an argument to a function. may be returned by a function, may be an element of a larger data structure (lists). lisp functions are first class objects (functions can take functions as parameters) ```

Question 31

explain mapcar by first making a square function (explain #')

Answer 31

``` #' - indicates argument is a function (mapcar #'square '(1 2 3 4 5)) > (1 4 9 16 25) ```

Question 32

explain funcall

Answer 32

(setq list #'+) (funcall list 1 2 3) >6 funcall allows use function names that are already being used

Question 33

describe eval, funcall and apply to add(1 2 3)

Answer 33

(eval '(+ 1 2 3)) (funcall #'+ 1 2 3) (apply #'+ '(1 2 3))

Question 34

explain lambda example use mapcar and square each and add 1

Answer 34

lambda creates temporary function with no name (mapcar (lambda (x) (+ (* x x) 1)) '(1 2 3 4))

Question 35

explain progn

Answer 35

evaluates a sequence of forms and returns value of last argument forms - lists that are to be evaluated

Question 36

make a struture and explain it (person with first, last and age)

Answer 36

(defstruct person first last age) | setf p1 (make-person :first 'fred :last 'jones :age 18)

Question 37

explain dolist and dotimes

Answer 37

(dolist (m list) (print m)) - goes through list prints each | (dotimes (x 6) (print x)) - prints 0 1 2 3 4 5 NIL