The document discusses the basics of the Lisp programming language including its prefix notation for functions, the use of lists to represent data structures, defining recursive functions using iterate, and how macros in Clojure allow rewriting expressions into different forms by transforming the abstract syntax tree. It provides examples of using basic functions like sum and + on lists of numbers, defining an iterate function, and a macro called infix that rewrites expressions into infix notation.

1. Learning Lisp
Alf Kristian Støyle

2. sum(1, 2);

3. sum(1, 2)

4. (sum 1, 2)

5. (sum 1 2)

6. (sum 1 2)

7. (sum 1 2)

8. Prefix notation
Function name Parameters
(sum 1 2)

9. (sum 1 2)

10. (sum)
(sum 1 2)
(sum 1 2 3)

11. (sum)
;=> 0
(sum 1 2)
;=> 3
(sum 1 2 3)
;=> 6

12. (+)
;=> 0
(+ 1 2)
;=> 3
(+ 1 2 3)
;=> 6

13. (+)
;=> 0
(+ 1 2) 1 + 2
;=> 3
(+ 1 2 3) 1 + 2 + 3
;=> 6

14. Lists
'(3 2 1)
;=> (3 2 1)
(+ 3 2 1)
;=> 6

15. Lists
'(3 2 1)
;=> (3 2 1)
(+ 3 2 1)
;=> 6
(defn iterate
[f x] (cons x (lazy-seq (iterate f (f x)))))

16. Lists
'(3 2 1)
;=> (3 2 1)
(+ 3 2 1)
;=> 6
(defn iterate
[f x] (cons x (lazy-seq (iterate f (f x)))))

17. Macros
(1 + 2)

18. Macros
(infix (1 + 2))
;=> 3

19. Macros
(infix (1 + 2))
;=> 3
(defmacro infix [form]
`(~(second form) ~(first form) ~@(nnext form)))

20. Macros
(infix (1 + 2))
;=> 3
(defmacro infix [form]
`(~(second form) ~(first form) ~@(nnext form)))
(macroexpand '(infix (1 + 2)))
;=> (+ 1 2)

21. (defn iterate
[f x] (cons x (lazy-seq (iterate f (f x)))))

22. Abstract syntax tree
(defn iterate
[f x] (cons x (lazy-seq (iterate f (f x)))))

24. Clojure