robot programming with lisp - 2. imperative...
TRANSCRIPT
![Page 1: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/1.jpg)
Artificial Intelligence
Robot Programming with Lisp2. Imperative Programming
Gayane Kazhoyan
Institute for Artificial IntelligenceUniversity of Bremen
26th October, 2017
![Page 2: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/2.jpg)
Artificial Intelligence
Lisp the Language
LISP ↔ LISt Processing language
(LISP ↔ Lots of Irritating Superfluous Parenthesis)
Copyright: XKCD
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp2
![Page 3: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/3.jpg)
Artificial Intelligence
Lisp the Language
LISP ↔ LISt Processing language
(LISP ↔ Lots of Irritating Superfluous Parenthesis)
Copyright: XKCD
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp3
![Page 4: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/4.jpg)
Artificial Intelligence
Technical Characteristics
• Dynamic typing : specifying the type of a variable is optional
• Garbage collection: first language to have an automated GC• Functions as first-class citizens (e.g. callbacks)• Anonymous functions• Side-effects are allowed, not purely functional as, e.g., Haskell• Run-time code generation• Easily-expandable through the powerful macros mechanism
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp4
![Page 5: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/5.jpg)
Artificial Intelligence
Technical Characteristics
• Dynamic typing : specifying the type of a variable is optional• Garbage collection: first language to have an automated GC
• Functions as first-class citizens (e.g. callbacks)• Anonymous functions• Side-effects are allowed, not purely functional as, e.g., Haskell• Run-time code generation• Easily-expandable through the powerful macros mechanism
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp5
![Page 6: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/6.jpg)
Artificial Intelligence
Technical Characteristics
• Dynamic typing : specifying the type of a variable is optional• Garbage collection: first language to have an automated GC• Functions as first-class citizens (e.g. callbacks)
• Anonymous functions• Side-effects are allowed, not purely functional as, e.g., Haskell• Run-time code generation• Easily-expandable through the powerful macros mechanism
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp6
![Page 7: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/7.jpg)
Artificial Intelligence
Technical Characteristics
• Dynamic typing : specifying the type of a variable is optional• Garbage collection: first language to have an automated GC• Functions as first-class citizens (e.g. callbacks)• Anonymous functions
• Side-effects are allowed, not purely functional as, e.g., Haskell• Run-time code generation• Easily-expandable through the powerful macros mechanism
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp7
![Page 8: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/8.jpg)
Artificial Intelligence
Technical Characteristics
• Dynamic typing : specifying the type of a variable is optional• Garbage collection: first language to have an automated GC• Functions as first-class citizens (e.g. callbacks)• Anonymous functions• Side-effects are allowed, not purely functional as, e.g., Haskell
• Run-time code generation• Easily-expandable through the powerful macros mechanism
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp8
![Page 9: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/9.jpg)
Artificial Intelligence
Technical Characteristics
• Dynamic typing : specifying the type of a variable is optional• Garbage collection: first language to have an automated GC• Functions as first-class citizens (e.g. callbacks)• Anonymous functions• Side-effects are allowed, not purely functional as, e.g., Haskell• Run-time code generation
• Easily-expandable through the powerful macros mechanism
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp9
![Page 10: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/10.jpg)
Artificial Intelligence
Technical Characteristics
• Dynamic typing : specifying the type of a variable is optional• Garbage collection: first language to have an automated GC• Functions as first-class citizens (e.g. callbacks)• Anonymous functions• Side-effects are allowed, not purely functional as, e.g., Haskell• Run-time code generation• Easily-expandable through the powerful macros mechanism
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp10
![Page 11: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/11.jpg)
Artificial Intelligence
Short History
• 1958: Lisp as a theoretical language designed by John McCarthy (MIT)
• 1958: First Lisp interpreter implementation by Steve Russel (MIT)• 1962: First Lisp compiler by Tim Hart and Mike Levin (MIT)• End of 1960s: MacLisp (MIT), Interlisp (Xerox, Stanford, DARPA)• 1975: Scheme (MIT)• 1976: Emacs and EmacsLisp by Richard Stallman and Guy Steele• 1970s - 2000s: Franz Lisp (UC Berkeley), NIL (MIT, Yale), AutoLISP(AutoCAD), Le Lisp (INRIA), PSL (Utah), CMUCL (CMU), T (Yale),Racket, SKILL, LFE (Lisp Flavoured Erlang), ISLISP (ISO standard), ...
• 1984: Common Lisp by Guy Steele, 1999: SBCL• 1990: Haskell, 1998 the first standard• 2004: ANSI Common Lisp• 2007: Clojure
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp11
![Page 12: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/12.jpg)
Artificial Intelligence
Short History
• 1958: Lisp as a theoretical language designed by John McCarthy (MIT)• 1958: First Lisp interpreter implementation by Steve Russel (MIT)
• 1962: First Lisp compiler by Tim Hart and Mike Levin (MIT)• End of 1960s: MacLisp (MIT), Interlisp (Xerox, Stanford, DARPA)• 1975: Scheme (MIT)• 1976: Emacs and EmacsLisp by Richard Stallman and Guy Steele• 1970s - 2000s: Franz Lisp (UC Berkeley), NIL (MIT, Yale), AutoLISP(AutoCAD), Le Lisp (INRIA), PSL (Utah), CMUCL (CMU), T (Yale),Racket, SKILL, LFE (Lisp Flavoured Erlang), ISLISP (ISO standard), ...
• 1984: Common Lisp by Guy Steele, 1999: SBCL• 1990: Haskell, 1998 the first standard• 2004: ANSI Common Lisp• 2007: Clojure
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp12
![Page 13: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/13.jpg)
Artificial Intelligence
Short History
• 1958: Lisp as a theoretical language designed by John McCarthy (MIT)• 1958: First Lisp interpreter implementation by Steve Russel (MIT)• 1962: First Lisp compiler by Tim Hart and Mike Levin (MIT)
• End of 1960s: MacLisp (MIT), Interlisp (Xerox, Stanford, DARPA)• 1975: Scheme (MIT)• 1976: Emacs and EmacsLisp by Richard Stallman and Guy Steele• 1970s - 2000s: Franz Lisp (UC Berkeley), NIL (MIT, Yale), AutoLISP(AutoCAD), Le Lisp (INRIA), PSL (Utah), CMUCL (CMU), T (Yale),Racket, SKILL, LFE (Lisp Flavoured Erlang), ISLISP (ISO standard), ...
• 1984: Common Lisp by Guy Steele, 1999: SBCL• 1990: Haskell, 1998 the first standard• 2004: ANSI Common Lisp• 2007: Clojure
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp13
![Page 14: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/14.jpg)
Artificial Intelligence
Short History
• 1958: Lisp as a theoretical language designed by John McCarthy (MIT)• 1958: First Lisp interpreter implementation by Steve Russel (MIT)• 1962: First Lisp compiler by Tim Hart and Mike Levin (MIT)• End of 1960s: MacLisp (MIT), Interlisp (Xerox, Stanford, DARPA)
• 1975: Scheme (MIT)• 1976: Emacs and EmacsLisp by Richard Stallman and Guy Steele• 1970s - 2000s: Franz Lisp (UC Berkeley), NIL (MIT, Yale), AutoLISP(AutoCAD), Le Lisp (INRIA), PSL (Utah), CMUCL (CMU), T (Yale),Racket, SKILL, LFE (Lisp Flavoured Erlang), ISLISP (ISO standard), ...
• 1984: Common Lisp by Guy Steele, 1999: SBCL• 1990: Haskell, 1998 the first standard• 2004: ANSI Common Lisp• 2007: Clojure
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp14
![Page 15: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/15.jpg)
Artificial Intelligence
Short History
• 1958: Lisp as a theoretical language designed by John McCarthy (MIT)• 1958: First Lisp interpreter implementation by Steve Russel (MIT)• 1962: First Lisp compiler by Tim Hart and Mike Levin (MIT)• End of 1960s: MacLisp (MIT), Interlisp (Xerox, Stanford, DARPA)• 1975: Scheme (MIT)
• 1976: Emacs and EmacsLisp by Richard Stallman and Guy Steele• 1970s - 2000s: Franz Lisp (UC Berkeley), NIL (MIT, Yale), AutoLISP(AutoCAD), Le Lisp (INRIA), PSL (Utah), CMUCL (CMU), T (Yale),Racket, SKILL, LFE (Lisp Flavoured Erlang), ISLISP (ISO standard), ...
• 1984: Common Lisp by Guy Steele, 1999: SBCL• 1990: Haskell, 1998 the first standard• 2004: ANSI Common Lisp• 2007: Clojure
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp15
![Page 16: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/16.jpg)
Artificial Intelligence
Short History
• 1958: Lisp as a theoretical language designed by John McCarthy (MIT)• 1958: First Lisp interpreter implementation by Steve Russel (MIT)• 1962: First Lisp compiler by Tim Hart and Mike Levin (MIT)• End of 1960s: MacLisp (MIT), Interlisp (Xerox, Stanford, DARPA)• 1975: Scheme (MIT)• 1976: Emacs and EmacsLisp by Richard Stallman and Guy Steele
• 1970s - 2000s: Franz Lisp (UC Berkeley), NIL (MIT, Yale), AutoLISP(AutoCAD), Le Lisp (INRIA), PSL (Utah), CMUCL (CMU), T (Yale),Racket, SKILL, LFE (Lisp Flavoured Erlang), ISLISP (ISO standard), ...
• 1984: Common Lisp by Guy Steele, 1999: SBCL• 1990: Haskell, 1998 the first standard• 2004: ANSI Common Lisp• 2007: Clojure
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp16
![Page 17: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/17.jpg)
Artificial Intelligence
Short History
• 1958: Lisp as a theoretical language designed by John McCarthy (MIT)• 1958: First Lisp interpreter implementation by Steve Russel (MIT)• 1962: First Lisp compiler by Tim Hart and Mike Levin (MIT)• End of 1960s: MacLisp (MIT), Interlisp (Xerox, Stanford, DARPA)• 1975: Scheme (MIT)• 1976: Emacs and EmacsLisp by Richard Stallman and Guy Steele• 1970s - 2000s: Franz Lisp (UC Berkeley), NIL (MIT, Yale), AutoLISP(AutoCAD), Le Lisp (INRIA), PSL (Utah), CMUCL (CMU), T (Yale),Racket, SKILL, LFE (Lisp Flavoured Erlang), ISLISP (ISO standard), ...
• 1984: Common Lisp by Guy Steele, 1999: SBCL• 1990: Haskell, 1998 the first standard• 2004: ANSI Common Lisp• 2007: Clojure
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp17
![Page 18: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/18.jpg)
Artificial Intelligence
Short History
• 1958: Lisp as a theoretical language designed by John McCarthy (MIT)• 1958: First Lisp interpreter implementation by Steve Russel (MIT)• 1962: First Lisp compiler by Tim Hart and Mike Levin (MIT)• End of 1960s: MacLisp (MIT), Interlisp (Xerox, Stanford, DARPA)• 1975: Scheme (MIT)• 1976: Emacs and EmacsLisp by Richard Stallman and Guy Steele• 1970s - 2000s: Franz Lisp (UC Berkeley), NIL (MIT, Yale), AutoLISP(AutoCAD), Le Lisp (INRIA), PSL (Utah), CMUCL (CMU), T (Yale),Racket, SKILL, LFE (Lisp Flavoured Erlang), ISLISP (ISO standard), ...
• 1984: Common Lisp by Guy Steele, 1999: SBCL
• 1990: Haskell, 1998 the first standard• 2004: ANSI Common Lisp• 2007: Clojure
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp18
![Page 19: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/19.jpg)
Artificial Intelligence
Short History
• 1958: Lisp as a theoretical language designed by John McCarthy (MIT)• 1958: First Lisp interpreter implementation by Steve Russel (MIT)• 1962: First Lisp compiler by Tim Hart and Mike Levin (MIT)• End of 1960s: MacLisp (MIT), Interlisp (Xerox, Stanford, DARPA)• 1975: Scheme (MIT)• 1976: Emacs and EmacsLisp by Richard Stallman and Guy Steele• 1970s - 2000s: Franz Lisp (UC Berkeley), NIL (MIT, Yale), AutoLISP(AutoCAD), Le Lisp (INRIA), PSL (Utah), CMUCL (CMU), T (Yale),Racket, SKILL, LFE (Lisp Flavoured Erlang), ISLISP (ISO standard), ...
• 1984: Common Lisp by Guy Steele, 1999: SBCL• 1990: Haskell, 1998 the first standard
• 2004: ANSI Common Lisp• 2007: Clojure
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp19
![Page 20: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/20.jpg)
Artificial Intelligence
Short History
• 1958: Lisp as a theoretical language designed by John McCarthy (MIT)• 1958: First Lisp interpreter implementation by Steve Russel (MIT)• 1962: First Lisp compiler by Tim Hart and Mike Levin (MIT)• End of 1960s: MacLisp (MIT), Interlisp (Xerox, Stanford, DARPA)• 1975: Scheme (MIT)• 1976: Emacs and EmacsLisp by Richard Stallman and Guy Steele• 1970s - 2000s: Franz Lisp (UC Berkeley), NIL (MIT, Yale), AutoLISP(AutoCAD), Le Lisp (INRIA), PSL (Utah), CMUCL (CMU), T (Yale),Racket, SKILL, LFE (Lisp Flavoured Erlang), ISLISP (ISO standard), ...
• 1984: Common Lisp by Guy Steele, 1999: SBCL• 1990: Haskell, 1998 the first standard• 2004: ANSI Common Lisp
• 2007: Clojure
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp20
![Page 21: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/21.jpg)
Artificial Intelligence
Short History
• 1958: Lisp as a theoretical language designed by John McCarthy (MIT)• 1958: First Lisp interpreter implementation by Steve Russel (MIT)• 1962: First Lisp compiler by Tim Hart and Mike Levin (MIT)• End of 1960s: MacLisp (MIT), Interlisp (Xerox, Stanford, DARPA)• 1975: Scheme (MIT)• 1976: Emacs and EmacsLisp by Richard Stallman and Guy Steele• 1970s - 2000s: Franz Lisp (UC Berkeley), NIL (MIT, Yale), AutoLISP(AutoCAD), Le Lisp (INRIA), PSL (Utah), CMUCL (CMU), T (Yale),Racket, SKILL, LFE (Lisp Flavoured Erlang), ISLISP (ISO standard), ...
• 1984: Common Lisp by Guy Steele, 1999: SBCL• 1990: Haskell, 1998 the first standard• 2004: ANSI Common Lisp• 2007: ClojureTheory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp21
![Page 22: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/22.jpg)
Artificial Intelligence
Hello World
Java “Hello World”public class HelloWorld {
public static void main(String[ ] args) {System.out.println("Hello World!");
}}
Lisp “Hello World”"Hello World!"
• Rapid prototyping• Read-Eval-Print Loop (Lisp shell)
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp22
![Page 23: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/23.jpg)
Artificial Intelligence
Hello World
Java “Hello World”public class HelloWorld {public static void main(String[ ] args) {
System.out.println("Hello World!");}
}
Lisp “Hello World”"Hello World!"
• Rapid prototyping• Read-Eval-Print Loop (Lisp shell)
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp23
![Page 24: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/24.jpg)
Artificial Intelligence
Hello World
Java “Hello World”public class HelloWorld {public static void main(String[ ] args) {
System.out.println("Hello World!");}
}
Lisp “Hello World”"Hello World!"
• Rapid prototyping• Read-Eval-Print Loop (Lisp shell)
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp24
![Page 25: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/25.jpg)
Artificial Intelligence
Hello World
Java “Hello World”public class HelloWorld {public static void main(String[ ] args) {
System.out.println("Hello World!");}
}
Lisp “Hello World”"Hello World!"
• Rapid prototyping• Read-Eval-Print Loop (Lisp shell)
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp25
![Page 26: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/26.jpg)
Artificial Intelligence
Polish Notation
Also known as prefix notation.
Examples(+ 1 2 3 4)
(sin 3.14)
(/ (+ 4 2) 3)
(list 1 2 3)
(defun return-my-arg (arg)arg)
(return-my-arg 302)
S-expressions (S for symbolic)
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp26
![Page 27: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/27.jpg)
Artificial Intelligence
NumbersIntegerCL-USER> (describe 1)1[fixnum]
FloatCL-USER> (describe 1.0)
(describe 1f0)1.0[single-float]
CL-USER> 1f31000.0
DoubleCL-USER> (describe 1d0)1.0d0[double-float]
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp27
![Page 28: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/28.jpg)
Artificial Intelligence
More Numbers
RatioCL-USER> (/ 1 3)1/3CL-USER> (describe 1/3)1/3[ratio]
CL-USER> (describe (/ 1.0 3))0.33333334[single-float]
Numeral SystemsCL-USER> #xFF255
CL-USER> #b111115
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp28
![Page 29: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/29.jpg)
Artificial Intelligence
Chars and Strings
CharCL-USER> (describe #\Z)#\Z[standard-char]
:_Char-code: 90:_Char-name: LATIN_CAPITAL_LETTER_Z
CL-USER> (describe #\Ö)#\LATIN_CAPITAL_LETTER_O_WITH_DIAERESIS[character]
:_Char-code: 214:_Char-name: LATIN_CAPITAL_LETTER_O_WITH_DIAERESIS
StringCL-USER> (describe "hello")"hello"[simple-string]
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp29
![Page 30: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/30.jpg)
Artificial Intelligence
Variables and Symbols
VariableCL-USER> x
The variable X is unbound.
SymbolCL-USER> (describe 'x)COMMON-LISP-USER::X[symbol]
KeywordCL-USER> (describe :x)
(describe ':x):X[symbol]
X names a constant variable:Value: :X
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp30
![Page 31: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/31.jpg)
Artificial Intelligence
Booleans
FalseCL-USER> (describe NIL)COMMON-LISP:NIL[null]
NIL names a constant variable:Value: NIL
NIL names a primitive type-specifier
TrueCL-USER> (describe T)COMMON-LISP:T[symbol]
T names a constant variable:Value: T
T names the built-in-class #<BUILT-IN-CLASS T>:...
T names a primitive type-specifier
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp31
![Page 32: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/32.jpg)
Artificial Intelligence
Lists
ListCL-USER> (list 1 2 3)(1 2 3)
CL-USER> *(1 2 3)
CL-USER> (describe *)(1 2 3)[list]
CL-USER> '(1 2 3)(1 2 3)
CL-USER> '((1.1 1.2) (2.1 2.2) (some more stuff) (+ 1 3))((1.1 1.2) (2.1 2.2) (SOME MORE STUFF) (+ 1 3))
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp32
![Page 33: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/33.jpg)
Artificial Intelligence
Lists Explained
1 2 3 NIL
It’s a linked list where each element has only 2 slots: value andnext-elem. next-elem of the last element is NIL.The elements are called cons cells or cons pairs.
List and NILCL-USER> '()NILCL-USER> (list )NILCL-USER> (type-of '(1 1 1))CONSCL-USER> (listp '(1 1 1))TCL-USER> (listp '())T
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp33
![Page 34: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/34.jpg)
Artificial Intelligence
Association Lists
A 1 B 2 C 3 NIL
It’s a list where the first element of each cons cell is itself a cons cell.
AListCL-USER> '((A . 1) (B . 2) (C . 3))((A . 1) (B . 2) (C . 3))
CL-USER> (describe *)((A . 1) (B . 2) (C . 3))[list]
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp34
![Page 35: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/35.jpg)
Artificial Intelligence
Arrays
VectorCL-USER> #(1 2 3)#(1 2 3)
MatrixCL-USER> #2A((1 2) (3 4))#2A((1 2) (3 4))
Mutli-dimensional arrayCL-USER> (make-array '(4 2 3)
:initial-contents'(((a b c) (1 2 3))
((d e f) (3 1 2))((g h i) (2 3 1))((j k l) (0 0 0))))
#3A(((A B C) (1 2 3)) ((D E F) (3 1 2)) ((G H I) (2 3 1)) ((J K L)(0 0 0)))
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp35
![Page 36: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/36.jpg)
Artificial Intelligence
Data Typest
character number
real
rational
integer ratio
float
complex
symbol sequence
list
null cons
array
vector
string simple-vector
simple-array
function
atom
list
The diagram is very simplified.Also, the following is completely omitted:
• standard-object (CLOS)• stream (files)• condition (error handling), ...
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp36
![Page 37: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/37.jpg)
Artificial Intelligence
Data and Code
Quoted constructs (both atoms and lists) are data:CL-USER> '"abc""abc"
CL-USER> '(+ 1 2)(+ 1 2)
Everything else is code:CL-USER> (+ 1 2)3
Conclusion: run-time code generation and manipulation done easily!CL-USER> (eval '(+ 1 2)) ; but don't EVER use "eval" directly3
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp37
![Page 38: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/38.jpg)
Artificial Intelligence
Code as Composition of ListsCode is one big nested list. Depending on the first element, anS-expression is compiled into a function, special form or macro.
FunctionCL-USER> '(list '+ 1 2)(LIST '+ 1 2)CL-USER> (eval *)(+ 1 2)CL-USER> (eval *)3
Special FormCL-USER> (list 'if t 1 2)(IF T
12)
CL-USER> (eval *)1
MacroCL-USER> (list 'defun 'return-a '(a) 'a)(DEFUN RETURN-A (A) A)CL-USER> (eval *)RETURN-ACL-USER> (return-a 5)5Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp38
![Page 39: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/39.jpg)
Artificial Intelligence
More on Symbols
SymbolCL-USER> (setf my-symbol 1)1CL-USER> (defun my-symbol () 2)MY-SYMBOLCL-USER> (setf (get 'my-symbol 'my-property) 3)3CL-USER> 'my-symbolMY-SYMBOL
SymbolField ValueName my-symbolPackage COMMON-LISP-USER aka CL-USERValue 1Function #<FUNCTION MY-SYMBOL>Property list (MY-PROPERTY 3)
To inspect an expressionin the REPL:right click → inspect.
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp39
![Page 40: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/40.jpg)
Artificial Intelligence
Read-Eval-Print Loop
expression
list
macro turn macro into code and execute it
special form evaluate only as defined in the form
function evaluate arguments then call function
atomsymbol symbol’s value slot
not-symbol value of itself
An example for special form REPLoop evaluation is the if command:
it evaluates only the first parameter, then chooses to evaluate either the second or third.
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp40
![Page 41: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/41.jpg)
Artificial Intelligence
Imperative Programming
The imperative programming paradigm represents programs assequences of commands.
One important property thereof is that the program has a state and thecommands manipulate it to achieve a desired state.
Common Lisp has powerful means for imperative programming (e.g., veryadvanced looping mechanisms) but many traditionally imperativeconstructs are implemented differently in Lisp.
We’ll consider both ways (imperative vs. functional) and then comparethem.
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp41
![Page 42: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/42.jpg)
Artificial Intelligence
Special Variables
Global VariablesCL-USER> (defvar *my-global-var* 'some-value "test variable")
*MY-GLOBAL-VAR*CL-USER> *my-global-var*SOME-VALUECL-USER> (setf *my-global-var* 23)23CL-USER> *my-global-var*23CL-USER> (incf *my-global-var*)24CL-USER> (defvar *my-global-var* 25)
*MY-GLOBAL-VAR*CL-USER> *my-global-var*24
Naming convention: *the-variable-name*.
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp42
![Page 43: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/43.jpg)
Artificial Intelligence
Special Variables [2]
ParametersCL-USER> (defparameter *my-param* 0.01)
*MY-PARAM*CL-USER> *my-param*0.01CL-USER> (setf *my-param* 0.1)0.1CL-USER> *my-param*0.1CL-USER> (defparameter *another-param*)error while parsing arguments to DEFMACRO DEFPARAMETERCL-USER> (defparameter *my-param* 0.5)
*MY-PARAM*CL-USER> *my-param*0.5
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp43
![Page 44: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/44.jpg)
Artificial Intelligence
Special Variables [3]
ConstantsCL-USER> (defconstant +my-pi+ 3.14)+MY-PI+CL-USER> +my-pi+3.14CL-USER> (setf +my-pi+ 3.14159)Condition: +MY-PI+ is a constant and thus can't be set.CL-USER> (defconstant +my-pi+ 3.14159)+MY-PI+Condition: The constant +MY-PI+ is being redefined.
Naming convention: +the-constant-name+.
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp44
![Page 45: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/45.jpg)
Artificial Intelligence
Local Variables
ConstantsCL-USER> (let ((a 1)
(b 2))(print a)b)
12CL-USER> (print b)The variable B is unbound.
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp45
![Page 46: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/46.jpg)
Artificial Intelligence
Type Operations
Predicates(type-of 5) ⇒ INTEGER(typep 5 'number) ⇒ T(type-of #c(5 1)) ⇒ COMPLEX(type-of 'nil) ⇒ NULL(listp '(1 2 3)) ⇒ T(symbolp 'a) ⇒ T(type-of :k) ⇒ KEYWORD(symbolp :k) ⇒ T
Casts(coerce '(a b c) 'vector) ⇒ #(A B C)(coerce "a" 'character) ⇒ #\a(coerce 7/2 'float) ⇒ 3.5(coerce 7/2 'number) ⇒ 7/2(coerce 7/2 't) ⇒ 7/2(coerce 7/2 'null) ⇒ 7/2 can't be converted to type NULL.
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp46
![Page 47: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/47.jpg)
Artificial Intelligence
Comparing
CastsCL-USER> (> 2 1.5d0)TCL-USER> (<= 3.0d0 3)TCL-USER> (eq 1 1)TCL-USER> (eq 'bla 'bla)TCL-USER> (eq "bla" "bla")NILCL-USER> (eq '(1 2 3) '(1 2 3))NILCL-USER> (eql '(1 2 3) '(1 2 3))NILCL-USER> (eql 1.0 1)NIL
CL-USER> (equal '(1 2 3) '(1 2 3))TCL-USER> (equal "bla" "bla")TCL-USER> (equal "bla" "Bla")NILCL-USER> (equalp "bla" "Bla")TCL-USER> (equal #(1 2 3) #(1 2 3))NILCL-USER> (equalp #(1 2 3) #(1 2 3))TCL-USER> (= 2.4 2.4d0)NILCL-USER> (string= "hello" "hello")T
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp47
![Page 48: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/48.jpg)
Artificial Intelligence
Comparing [2]
x y eq eql equal equalp’a ’a T T T T0 0 ? T T T
’(a) ’(a) nil nil T T“ab” “ab” nil nil T T“Ab” “aB” nil nil nil T0 0.0 nil nil nil T0 1 nil nil nil nil
= is for comparing numbers of the same type.
string= is an advanced tool for comparing strings.
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp48
![Page 49: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/49.jpg)
Artificial Intelligence
List Operations
ListsCL-USER> (cons 1 (cons 2 (cons 3 nil)))CL-USER> (list 1 2 3)CL-USER> '(1 2 3)(1 2 3)
CL-USER> (listp *)TCL-USER> (null **)NILCL-USER> (null '())TCL-USER> (null '(()))NILCL-USER> (member 2 '(1 2 3))(2 3)CL-USER> (member 2 '((1 2) (3 4)))NIL
CL-USER> (defvar *my-list*'(1 2 3 4 5))
*MY-LIST*CL-USER> (first *my-list*)1CL-USER> (rest *my-list*)(2 3 4 5)CL-USER> (nth 4 *my-list*)5CL-USER> (fourth *my-list*)4CL-USER> (last *my-list*)(5)
CL-USER> (push 0 *my-list*)(0 1 2 3 4 5)
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp49
![Page 50: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/50.jpg)
Artificial Intelligence
AList Operations
Association ListsCL-USER> (cons (cons "Alice" "Jones")
(cons (cons "Bill" "Smith")(cons (cons "Cathy" "Smith")
nil)))(("Alice" . "Jones") ("Bill" . "Smith") ("Cathy" . "Smith"))CL-USER> '(("Alice" . "Jones") ("Bill" . "Smith") ("Cathy" . "Smith"))(("Alice" . "Jones") ("Bill" . "Smith") ("Cathy" . "Smith"))CL-USER> (assoc "Alice" *)NILCL-USER> (assoc "Alice" ** :test \#'string=)("Alice" . "Jones")CL-USER> (rassoc "Smith" *** :test \#'string=)("Bill" . "Smith")
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp50
![Page 51: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/51.jpg)
Artificial Intelligence
Property Lists and Vectors
Property ListsCL-USER> (defvar *plist* '())
*PLIST*CL-USER> (setf (getf *plist* 'key) 'value)VALUECL-USER> *plist*(KEY VALUE)CL-USER> (setf (getf *plist* 'another-key)
'another-value)ANOTHER-VALUECL-USER> *plist*(ANOTHER-KEY ANOTHER-VALUE KEY VALUE)CL-USER> (setf (getf *plist* 'key)
'new-value)NEW-VALUECL-USER> *plist*(ANOTHER-KEY ANOTHER-VALUE KEY NEW-VALUE)
VectorsCL-USER> #2A((1 2) (3 4))#2A((1 2) (3 4))CL-USER> (aref * 0 0)1CL-USER> (aref ** 1 1)4CL-USER> #(1 2 3 4 5 6)#(1 2 3 4 5 6)CL-USER> (setf (aref * 5) 9)9CL-USER> **#(1 2 3 4 5 9)
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp51
![Page 52: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/52.jpg)
Artificial Intelligence
I/O
Format Statements, Streams and FilesCL-USER> (read)hello worldHELLOCL-USER> (read-line)hello world"hello world"CL-USER> (format nil "symbol to ~a" 'string)"symbol to STRING"CL-USER> (format t "1 + 1 = ~a~%" (+ 1 1))1 + 1 = 2NILCL-USER>(with-open-file (stream "~/.bashrc")
(do ((line (read-line stream nil)(read-line stream nil)))
((null line))(print line)))
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp52
![Page 53: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/53.jpg)
Artificial Intelligence
Program Flow Constructsif, case, unlessCL-USER> (defvar *weather* 'rainy)
*WEATHER*CL-USER> (if (eql *weather* 'rainy)
(format t "I'm staying at home.")(format t "Let's go for a walk!"))
I'm staying at home.NILCL-USER> (case *weather*
(rainy "Stay home")(snowing "Go ski")(sunny "Got to the park")(otherwise "Hmmm..."))
"Stay home"CL-USER> (setf *weather* 'very-nice)VERY-NICECL-USER> (unless (eql *weather* 'rainy)
(format t "Let's go for a walk!"))Let's go for a walk!Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp53
![Page 54: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/54.jpg)
Artificial Intelligence
Program Flow Constructs [2]
when, prognCL-USER> (setf *weather* 'rainy)RAINYCL-USER> (if (eql *weather* 'rainy)
(progn(format t "Let's go for a walk.~%")(format t "But don't forget your umbrella.~%")))
Let's go for a walk.But don't forget your umbrella.NILCL-USER> (when (eql *weather* 'rainy)
(format t "Let's go for a walk.~%")(format t "But don't forget your umbrella.~%"))
Let's go for a walk.But don't forget your umbrella.NIL
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp54
![Page 55: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/55.jpg)
Artificial Intelligence
Program Flow Constructs [3]
prog1, condCL-USER> (progn (setf *weather* 'it-rains-cats)
(format t "The weather today is ~a~%" *weather*))The weather today is IT-RAINS-CATSNILCL-USER> (prog1 (setf *weather* 'whatever)
(format t "The weather today is ~a~%" *weather*))The weather today is WHATEVERWHATEVER
CL-USER> (defvar *x* 1.5)
*X*CL-USER> (cond ((< *x* 0) -*x*)
((< *x* 1) 1)(t *x*))
1.5
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp55
![Page 56: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/56.jpg)
Artificial Intelligence
Logical Operators
and, or, notCL-USER> (defparameter *threshold* 0.001)
*THRESHOLD*CL-USER> (if (not (and (<= *threshold* 1) (> *threshold* 0)))
(error "*threshold* should lie within (0; 1]~%"))NILCL-USER> (if (or (> *threshold* 1) (<= *threshold* 0))
(error "*threshold* should lie within (0; 1]~%"))NILCL-USER> (unless (and (<= *threshold* 1) (> *threshold* 0))
(error "*threshold* should lie within (0; 1]~%"))NIL
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp56
![Page 57: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/57.jpg)
Artificial Intelligence
Loopingdotimes, dolist, loopCL-USER> (dotimes (i 10 (format t "the end~%"))
(format t "~d " i))0 1 2 3 4 5 6 7 8 9 the endNILCL-USER> (defparameter *random* (loop repeat 10 collect (random 10000)))
*RANDOM*CL-USER> (dolist (element *random* (format t "...~%"))
(format t "~a " element))6505 5293 2987 2440 8012 3258 9871 896 2501 5158 ...NILCL-USER> (loop for i in *random*
counting (evenp i) into evenscounting (oddp i) into oddssumming i into totalmaximizing i into maxminimizing i into minfinally (return (list evens odds total max min)))
(5 5 46921 9871 896)Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp57
![Page 58: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/58.jpg)
Artificial Intelligence
Defining a Function and Calling It
Defining a FunctionCL-USER>(defun my-cool-function-name (arg-1 arg-2 arg-3 arg-4)"This function combines its 4 input arguments into a list
and returns it."(list arg-1 arg-2 arg-3 arg-4))
MY-COOL-FUNCTION-NAME
Calling a FunctionCL-USER> (my-cool-function-name 1 3 5 7)(1 3 5 7)
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp58
![Page 59: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/59.jpg)
Artificial Intelligence
Documentation
Slime hotkeys (in the REPL or .lisp file):
C-c C-d d describe symbol at pointC-c C-d f describe function at pointC-c C-d h open Hyperspec definitionC-c C-d C-h list all Slime bindings for getting documentationM-. go into function definitionM-, return one level up from the definition stackC-c M-m macroexpand expression at pointC-c C-v i inspect presentation at point (only in REPL)
(or right click → inspect)
Hint: cursor is called “point” in Emacs.
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp59
![Page 60: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/60.jpg)
Artificial Intelligence
Assignment goals
Lisp basics
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp60
![Page 61: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/61.jpg)
Artificial Intelligence
Task 1: Update your repository
• Go to your lisp_course_material directory and update it:roscd && cd ../src/lisp_course_material
git pull origin master
• You will see a new directory that appeared there (assignment_2):ll
• Compile your workspace with the new assignment:cd ../.. && catkin_make && rospack profile
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp61
![Page 62: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/62.jpg)
Artificial Intelligence
Task 2: Lisp Homework
• Your Lisp assignment is in assignment_2/src/...• (Re)start your Lisp REPL:
roslisp_repl &
• Load the package code:CL-USER> (ros-load:load-system "assignment_2" :assignment-2)
• Follow the instructions in the simple-world.lisp file.• Commit and push the changes once finished:
git add .
git commit -m "finished assignment_2"
git push my-repo master
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp62
![Page 63: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/63.jpg)
Artificial Intelligence
Links
• Revenge of the nerds:http://www.paulgraham.com/icad.html
• Paredit cheat sheet:http://pub.gajendra.net/src/paredit-refcard.pdf
• Practical Common Lisp online book:http://www.gigamonkeys.com/book/
• The Little Schemer examples book:http://www.ccs.neu.edu/home/matthias/BTLS/
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp63
![Page 64: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/64.jpg)
Artificial Intelligence
Info summary
Assignment:• Due: 01.11., Wednesday, 23:59 German time• Points: 7 points
Next class:• Date: 02.11.• Time: 14:15• Place: same room (TAB 0.31)• Lecturer: Arthur
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp64
![Page 65: Robot Programming with Lisp - 2. Imperative Programmingai.uni-bremen.de/_media/teaching/2_imperative.pdf · Robot Programming with Lisp 2. Artificial ... (UCBerkeley),NIL(MIT,Yale),AutoLISP](https://reader033.vdocuments.us/reader033/viewer/2022052300/5a7e01b97f8b9a66798e1cdb/html5/thumbnails/65.jpg)
Artificial Intelligence
Q & A
Thanks for your attention!
Theory Assignment
Gayane Kazhoyan
26th October, 2017
Robot Programming with Lisp65