Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence...
Transcript of Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence...
![Page 1: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/1.jpg)
Artificial Intelligence
Robot Programming with Lisp3. Functional Programming:
Functions, Lexical Scope and Closures
Gayane Kazhoyan
Institute for Artificial IntelligenceUniversität Bremen
19th April, 2016
![Page 2: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/2.jpg)
Artificial Intelligence
Outline
Background
Theory
Organizational
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp2
![Page 3: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/3.jpg)
Artificial Intelligence
Functional ProgrammingPure functional programming concepts include:
• no program state (e.g. no global variables);
• referential transparency, i.e. a function called twice with samearguments always generates the same output;
• functions don’t have side effects;• avoid mutable data, i.e. once created, data structure values don’tchange (immutable data);
• heavy usage of recursions, as opposed to iterative approaches;• functions as first class citizens, as a result, higher-order functions(simplest analogy: callbacks);
• lazy evaluations, i.e. only execute a function call when its result isactually used;
• usage of lists as a main data structure; ....
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp3
![Page 4: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/4.jpg)
Artificial Intelligence
Functional ProgrammingPure functional programming concepts include:
• no program state (e.g. no global variables);• referential transparency, i.e. a function called twice with samearguments always generates the same output;
• functions don’t have side effects;• avoid mutable data, i.e. once created, data structure values don’tchange (immutable data);
• heavy usage of recursions, as opposed to iterative approaches;• functions as first class citizens, as a result, higher-order functions(simplest analogy: callbacks);
• lazy evaluations, i.e. only execute a function call when its result isactually used;
• usage of lists as a main data structure; ....
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp4
![Page 5: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/5.jpg)
Artificial Intelligence
Functional ProgrammingPure functional programming concepts include:
• no program state (e.g. no global variables);• referential transparency, i.e. a function called twice with samearguments always generates the same output;
• functions don’t have side effects;
• avoid mutable data, i.e. once created, data structure values don’tchange (immutable data);
• heavy usage of recursions, as opposed to iterative approaches;• functions as first class citizens, as a result, higher-order functions(simplest analogy: callbacks);
• lazy evaluations, i.e. only execute a function call when its result isactually used;
• usage of lists as a main data structure; ....
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp5
![Page 6: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/6.jpg)
Artificial Intelligence
Functional ProgrammingPure functional programming concepts include:
• no program state (e.g. no global variables);• referential transparency, i.e. a function called twice with samearguments always generates the same output;
• functions don’t have side effects;• avoid mutable data, i.e. once created, data structure values don’tchange (immutable data);
• heavy usage of recursions, as opposed to iterative approaches;• functions as first class citizens, as a result, higher-order functions(simplest analogy: callbacks);
• lazy evaluations, i.e. only execute a function call when its result isactually used;
• usage of lists as a main data structure; ....
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp6
![Page 7: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/7.jpg)
Artificial Intelligence
Functional ProgrammingPure functional programming concepts include:
• no program state (e.g. no global variables);• referential transparency, i.e. a function called twice with samearguments always generates the same output;
• functions don’t have side effects;• avoid mutable data, i.e. once created, data structure values don’tchange (immutable data);
• heavy usage of recursions, as opposed to iterative approaches;
• functions as first class citizens, as a result, higher-order functions(simplest analogy: callbacks);
• lazy evaluations, i.e. only execute a function call when its result isactually used;
• usage of lists as a main data structure; ....
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp7
![Page 8: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/8.jpg)
Artificial Intelligence
Functional ProgrammingPure functional programming concepts include:
• no program state (e.g. no global variables);• referential transparency, i.e. a function called twice with samearguments always generates the same output;
• functions don’t have side effects;• avoid mutable data, i.e. once created, data structure values don’tchange (immutable data);
• heavy usage of recursions, as opposed to iterative approaches;• functions as first class citizens, as a result, higher-order functions(simplest analogy: callbacks);
• lazy evaluations, i.e. only execute a function call when its result isactually used;
• usage of lists as a main data structure; ....
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp8
![Page 9: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/9.jpg)
Artificial Intelligence
Functional ProgrammingPure functional programming concepts include:
• no program state (e.g. no global variables);• referential transparency, i.e. a function called twice with samearguments always generates the same output;
• functions don’t have side effects;• avoid mutable data, i.e. once created, data structure values don’tchange (immutable data);
• heavy usage of recursions, as opposed to iterative approaches;• functions as first class citizens, as a result, higher-order functions(simplest analogy: callbacks);
• lazy evaluations, i.e. only execute a function call when its result isactually used;
• usage of lists as a main data structure; ....
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp9
![Page 10: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/10.jpg)
Artificial Intelligence
Functional ProgrammingPure functional programming concepts include:
• no program state (e.g. no global variables);• referential transparency, i.e. a function called twice with samearguments always generates the same output;
• functions don’t have side effects;• avoid mutable data, i.e. once created, data structure values don’tchange (immutable data);
• heavy usage of recursions, as opposed to iterative approaches;• functions as first class citizens, as a result, higher-order functions(simplest analogy: callbacks);
• lazy evaluations, i.e. only execute a function call when its result isactually used;
• usage of lists as a main data structure; ....Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp10
![Page 11: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/11.jpg)
Artificial Intelligence
Popular Languages
• Scheme: 1975, latest release in 2013, introduced many core functionalprogramming concepts that are widely accepted today
• Common Lisp: 1984, latest release (SBCL) in 2016, successor ofScheme, possibly the most influential, general-purpose, widely-usedLisp dialect
• Erlang: 1986, latest release in 2016, focused on concurrency anddistributed systems, supports hot patching, used within AWS
• Haskell: 1990, latest release in 2010, purely functional, in contrast toall others in this list
• Racket: 1994, latest release in 2016, focused on writingdomain-specific programming languages
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp11
![Page 12: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/12.jpg)
Artificial Intelligence
Popular Languages
• Scheme: 1975, latest release in 2013, introduced many core functionalprogramming concepts that are widely accepted today
• Common Lisp: 1984, latest release (SBCL) in 2016, successor ofScheme, possibly the most influential, general-purpose, widely-usedLisp dialect
• Erlang: 1986, latest release in 2016, focused on concurrency anddistributed systems, supports hot patching, used within AWS
• Haskell: 1990, latest release in 2010, purely functional, in contrast toall others in this list
• Racket: 1994, latest release in 2016, focused on writingdomain-specific programming languages
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp12
![Page 13: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/13.jpg)
Artificial Intelligence
Popular Languages
• Scheme: 1975, latest release in 2013, introduced many core functionalprogramming concepts that are widely accepted today
• Common Lisp: 1984, latest release (SBCL) in 2016, successor ofScheme, possibly the most influential, general-purpose, widely-usedLisp dialect
• Erlang: 1986, latest release in 2016, focused on concurrency anddistributed systems, supports hot patching, used within AWS
• Haskell: 1990, latest release in 2010, purely functional, in contrast toall others in this list
• Racket: 1994, latest release in 2016, focused on writingdomain-specific programming languages
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp13
![Page 14: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/14.jpg)
Artificial Intelligence
Popular Languages
• Scheme: 1975, latest release in 2013, introduced many core functionalprogramming concepts that are widely accepted today
• Common Lisp: 1984, latest release (SBCL) in 2016, successor ofScheme, possibly the most influential, general-purpose, widely-usedLisp dialect
• Erlang: 1986, latest release in 2016, focused on concurrency anddistributed systems, supports hot patching, used within AWS
• Haskell: 1990, latest release in 2010, purely functional, in contrast toall others in this list
• Racket: 1994, latest release in 2016, focused on writingdomain-specific programming languages
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp14
![Page 15: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/15.jpg)
Artificial Intelligence
Popular Languages
• Scheme: 1975, latest release in 2013, introduced many core functionalprogramming concepts that are widely accepted today
• Common Lisp: 1984, latest release (SBCL) in 2016, successor ofScheme, possibly the most influential, general-purpose, widely-usedLisp dialect
• Erlang: 1986, latest release in 2016, focused on concurrency anddistributed systems, supports hot patching, used within AWS
• Haskell: 1990, latest release in 2010, purely functional, in contrast toall others in this list
• Racket: 1994, latest release in 2016, focused on writingdomain-specific programming languages
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp15
![Page 16: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/16.jpg)
Artificial Intelligence
Popular Languages [2]
• OCaml: 1996, latest release in 2015, very high performance,static-typed, one of the first inherently object-oriented functionalprogramming languages
• Scala: 2003, latest release in 2016, compiled to JVM code,static-typed, object-oriented, Java-like syntax {}
• Clojure: 2007, latest release in 2016, compiled to JVM code andJavaScript, therefore mostly used in Web, seems to be fashionable inthe programming subculture at the moment
• Julia: 2012, latest release in 2016, focused on high-performancenumerical and scientific computing, means for distributed computation,strong FFI support, Python-like syntax
Conclusion: functional programming becomes more and more popular.
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp16
![Page 17: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/17.jpg)
Artificial Intelligence
Popular Languages [2]
• OCaml: 1996, latest release in 2015, very high performance,static-typed, one of the first inherently object-oriented functionalprogramming languages
• Scala: 2003, latest release in 2016, compiled to JVM code,static-typed, object-oriented, Java-like syntax {}
• Clojure: 2007, latest release in 2016, compiled to JVM code andJavaScript, therefore mostly used in Web, seems to be fashionable inthe programming subculture at the moment
• Julia: 2012, latest release in 2016, focused on high-performancenumerical and scientific computing, means for distributed computation,strong FFI support, Python-like syntax
Conclusion: functional programming becomes more and more popular.
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp17
![Page 18: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/18.jpg)
Artificial Intelligence
Popular Languages [2]
• OCaml: 1996, latest release in 2015, very high performance,static-typed, one of the first inherently object-oriented functionalprogramming languages
• Scala: 2003, latest release in 2016, compiled to JVM code,static-typed, object-oriented, Java-like syntax {}
• Clojure: 2007, latest release in 2016, compiled to JVM code andJavaScript, therefore mostly used in Web, seems to be fashionable inthe programming subculture at the moment
• Julia: 2012, latest release in 2016, focused on high-performancenumerical and scientific computing, means for distributed computation,strong FFI support, Python-like syntax
Conclusion: functional programming becomes more and more popular.
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp18
![Page 19: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/19.jpg)
Artificial Intelligence
Popular Languages [2]
• OCaml: 1996, latest release in 2015, very high performance,static-typed, one of the first inherently object-oriented functionalprogramming languages
• Scala: 2003, latest release in 2016, compiled to JVM code,static-typed, object-oriented, Java-like syntax {}
• Clojure: 2007, latest release in 2016, compiled to JVM code andJavaScript, therefore mostly used in Web, seems to be fashionable inthe programming subculture at the moment
• Julia: 2012, latest release in 2016, focused on high-performancenumerical and scientific computing, means for distributed computation,strong FFI support, Python-like syntax
Conclusion: functional programming becomes more and more popular.
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp19
![Page 20: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/20.jpg)
Artificial Intelligence
Popular Languages [2]
• OCaml: 1996, latest release in 2015, very high performance,static-typed, one of the first inherently object-oriented functionalprogramming languages
• Scala: 2003, latest release in 2016, compiled to JVM code,static-typed, object-oriented, Java-like syntax {}
• Clojure: 2007, latest release in 2016, compiled to JVM code andJavaScript, therefore mostly used in Web, seems to be fashionable inthe programming subculture at the moment
• Julia: 2012, latest release in 2016, focused on high-performancenumerical and scientific computing, means for distributed computation,strong FFI support, Python-like syntax
Conclusion: functional programming becomes more and more popular.Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp20
![Page 21: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/21.jpg)
Artificial Intelligence
Outline
Background
Theory
Organizational
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp21
![Page 22: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/22.jpg)
Artificial Intelligence
Defining a Function
SignatureCL-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))
Optional ArgumentsCL-USER> (defun optional-arguments (arg-1 arg-2 &optional arg-3 arg-4)
(list arg-1 arg-2 arg-3 arg-4))CL-USER> (optional-arguments 1 2 3 4)(1 2 3 4)CL-USER> (optional-arguments 1 2 3)(1 2 3 NIL)CL-USER> (optional-arguments 304)invalid number of arguments: 1
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp22
![Page 23: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/23.jpg)
Artificial Intelligence
Defining a Function [2]
Key ArgumentsCL-USER>(defun specific-optional (arg-1 arg-2 &key arg-3 arg-4)"This function demonstrates how to pass a value to
a specific optional argument."(list arg-1 arg-2 arg-3 arg-4))
SPECIFIC-OPTIONAL
CL-USER> (specific-optional 1 2 3 4)unknown &KEY argument: 3
CL-USER> (specific-optional 1 2 :arg-4 4)(1 2 NIL 4)
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp23
![Page 24: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/24.jpg)
Artificial Intelligence
Defining a Function [3]
Unlimited Number of ArgumentsCL-USER> (defun unlimited-args (arg-1 &rest args)
(format t "Type of args is ~a.~%" (type-of args))(cons (list arg-1) args))
UNLIMITED-ARGS
CL-USER> (unlimited-args 1 2 3 4)Type of args is CONS.(1 2 3 4)
CL-USER> (unlimited-args 1)Type of args is NULL.(1)
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp24
![Page 25: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/25.jpg)
Artificial Intelligence
Multiple Values
list vs. valuesCL-USER> (defvar *some-list* (list 1 2 3))
*SOME-LIST*CL-USER> *some-list*(1 2 3)CL-USER> (defvar *values?* (values 1 2 3))
*VALUES?*CL-USER> *values?*1CL-USER> (values 1 2 3)123CL-USER> *1CL-USER> //(1 2 3)
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp25
![Page 26: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/26.jpg)
Artificial Intelligence
Multiple Values [2]
Returning Multiple Values!CL-USER> (defvar *db* '((Anna 1987) (Bob 1899) (Charlie 1980)))
(defun name-and-birth-year (id)(values (first (nth (- id 1) *db*))
(second (nth (- id 1) *db*))))NAME-AND-BIRTH-YEAR
CL-USER> (name-and-birth-year 2)BOB1899
CL-USER> (multiple-value-bind (name year) (name-and-birth-year 2)(format t "~a was born in ~a.~%" name year))
BOB was born in 1899.NIL
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp26
![Page 27: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/27.jpg)
Artificial Intelligence
Function DesignatorsSimilar to C pointers or Java references
Designator of a FunctionCL-USER> (describe '+)COMMON-LISP:+[symbol]
+ names a special variable:+ names a compiled function:CL-USER> #'+CL-USER> (symbol-function '+)#<FUNCTION +>CL-USER> (describe #'+)#<FUNCTION +>[compiled function]
Lambda-list: (&REST NUMBERS)Declared type: (FUNCTION (&REST NUMBER) (VALUES NUMBER &OPTIONAL))Derived type: (FUNCTION (&REST T) (VALUES NUMBER &OPTIONAL))Documentation: ...Source file: SYS:SRC;CODE;NUMBERS.LISP
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp27
![Page 28: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/28.jpg)
Artificial Intelligence
Higher-order Functions
Function as ArgumentCL-USER> (funcall #'+ 1 2 3)CL-USER> (apply #'+ '(1 2 3))6CL-USER> (defun transform-1 (num) (/ 1.0 num))TRANSFORM-1CL-USER> (defun transform-2 (num) (sqrt num))TRANSFORM-2CL-USER> (defun print-transformed (a-number a-function)
(format t "~a transformed with ~a becomes ~a.~%"a-number a-function (funcall a-function a-number)))
PRINT-TRANSFORMEDCL-USER> (print-transformed 4 #'transform-1)4 transformed with #<FUNCTION TRANSFORM-1> becomes 0.25.CL-USER> (print-transformed 4 #'transform-2)4 transformed with #<FUNCTION TRANSFORM-2> becomes 2.0.CL-USER> (sort '(2 6 3 7 1 5) #'>)(7 6 5 3 2 1)
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp28
![Page 29: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/29.jpg)
Artificial Intelligence
Higher-order Functions [2]
Function as Return ValueCL-USER> (defun give-me-some-function ()
(case (random 5)(0 #'+)(1 #'-)(2 #'*)(3 #'/)(4 #'values)))
GIVE-ME-SOME-FUNCTION
CL-USER> (give-me-some-function)#<FUNCTION ->
CL-USER> (funcall (give-me-some-function) 10 5)5
CL-USER> (funcall (give-me-some-function) 10 5)2
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp29
![Page 30: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/30.jpg)
Artificial Intelligence
Anonymous Functions
lambdaCL-USER> (sort '((1 2 3 4) (3 4) (6 3 6)) #'>)The value (3 4) is not of type NUMBER.CL-USER> (sort '((1 2 3 4) (3 4) (6 3 6))
(lambda (x y)(> (length x) (length y))))
((1 2 3 4) (6 3 6) (3 4))CL-USER> (sort '((1 2 3 4) (3 4) (6 3 6)) #'> :key #'car)((6 3 6) (3 4) (1 2 3 4))
CL-USER> (defun random-generator-a-to-b (a b)(lambda () (+ (random (- b a)) a)))
RANDOM-GENERATOR-A-TO-BCL-USER> (random-generator-a-to-b 5 10)#<CLOSURE (LAMBDA () :IN RANDOM-GENERATOR-A-TO-B) {100D31F90B}>CL-USER> (funcall (random-generator-a-to-b 5 10))9
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp30
![Page 31: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/31.jpg)
Artificial Intelligence
The let Environment
letCL-USER> (let ((a 1)
(b 2))(values a b))
12CL-USER> (values a b)The variable A is unbound.
CL-USER> (defvar some-var 'global)(let ((some-var 'outer))
(let ((some-var 'inter))(format t "some-var inner: ~a~%" some-var))
(format t "some-var outer: ~a~%" some-var))(format t "global-var: ~a~%" some-var)
?
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp31
![Page 32: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/32.jpg)
Artificial Intelligence
The let Environment
letCL-USER> (let ((a 1)
(b 2))(values a b))
12CL-USER> (values a b)The variable A is unbound.
CL-USER> (defvar some-var 'global)(let ((some-var 'outer))
(let ((some-var 'inter))(format t "some-var inner: ~a~%" some-var))
(format t "some-var outer: ~a~%" some-var))(format t "global-var: ~a~%" some-var)
some-var inner: INTERsome-var outer: OUTERglobal-var: GLOBAL
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp32
![Page 33: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/33.jpg)
Artificial Intelligence
The let Environment [2]
let*CL-USER> (let ((a 4)
(a^2 (expt a 2)))(values a a^2))
The variable A is unbound.
CL-USER> (let* ((a 4)(a^2 (expt a 2)))
(values a a^2))416
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp33
![Page 34: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/34.jpg)
Artificial Intelligence
Lexical Variables
In Lisp, non-global variable values are, when possible, determined atcompile time. They are bound lexically, i.e. they are bound to thecode they’re defined in, not to the run-time state of the program.
RiddleCL-USER> (let* ((lexical-var 304)
(some-lambda (lambda () (+ lexical-var 100))))(setf lexical-var 4)(funcall some-lambda))
?
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp34
![Page 35: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/35.jpg)
Artificial Intelligence
Lexical Variables
In Lisp, non-global variable values are, when possible, determined atcompile time. They are bound lexically, i.e. they are bound to thecode they’re defined in, not to the run-time state of the program.
RiddleCL-USER> (let* ((lexical-var 304)
(some-lambda (lambda () (+ lexical-var 100))))(setf lexical-var 4)(funcall some-lambda))
104
This is one single let block, therefore lexical-var is the same every-where in the block.
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp35
![Page 36: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/36.jpg)
Artificial Intelligence
Lexical Variables [2]
Lexical scope with lambda and defunCL-USER> (defun return-x (x)
(let ((x 304))x))
(return-x 3)?
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp36
![Page 37: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/37.jpg)
Artificial Intelligence
Lexical Variables [2]
Lexical scope with lambda and defunCL-USER> (defun return-x (x)
(let ((x 304))x))
(return-x 3)304
lambda-s and defun-s create lexical local variables per default.
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp37
![Page 38: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/38.jpg)
Artificial Intelligence
Lexical Variables [3]
More ExamplesCL-USER> (let* ((lexical-var 304)
(some-lambda (lambda () (+ lexical-var 100))))(setf lexical-var 4)(funcall some-lambda))
104CL-USER> lexical-var?
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp38
![Page 39: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/39.jpg)
Artificial Intelligence
Lexical Variables [3]
More ExamplesCL-USER> (let* ((lexical-var 304)
(some-lambda (lambda () (+ lexical-var 100))))(setf lexical-var 4)(funcall some-lambda))
104CL-USER> lexical-var; Evaluation aborted on #<UNBOUND-VARIABLE LEXICAL-VAR {100AA9C403}>.
CL-USER> (let ((another-var 304)(another-lambda (lambda () (+ another-var 100))))
(setf another-var 4)(funcall another-lambda))
?
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp39
![Page 40: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/40.jpg)
Artificial Intelligence
Lexical Variables [3]
More ExamplesCL-USER> (let* ((lexical-var 304)
(some-lambda (lambda () (+ lexical-var 100))))(setf lexical-var 4)(funcall some-lambda))
104CL-USER> lexical-var; Evaluation aborted on #<UNBOUND-VARIABLE LEXICAL-VAR {100AA9C403}>.
CL-USER> (let ((another-var 304)(another-lambda (lambda () (+ another-var 100))))
(setf another-var 4)(funcall another-lambda))
; caught WARNING:; undefined variable: ANOTHER-VAR; Evaluation aborted on #<UNBOUND-VARIABLE ANOTHER-VAR {100AD51473}>.
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp40
![Page 41: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/41.jpg)
Artificial Intelligence
Lexical Variables [3]
More ExamplesCL-USER> (let ((other-lambda (lambda () (+ other-var 100))))
(setf other-var 4)(funcall other-lambda))
?
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp41
![Page 42: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/42.jpg)
Artificial Intelligence
Lexical Variables [3]
More ExamplesCL-USER> (let ((other-lambda (lambda () (+ other-var 100))))
(setf other-var 4)(funcall other-lambda))
; caught WARNING:; undefined variable: OTHER-VAR104CL-USER> other-var4CL-USER> (describe 'other-var)COMMON-LISP-USER::OTHER-VAR[symbol]
OTHER-VAR names an undefined variable:Value: 4
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp42
![Page 43: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/43.jpg)
Artificial Intelligence
Lexical Variables [3]
More ExamplesCL-USER> (let ((some-var 304))
(defun some-fun () (+ some-var 100))(setf some-var 4)(funcall #'some-fun))
?
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp43
![Page 44: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/44.jpg)
Artificial Intelligence
Lexical Variables [3]
More ExamplesCL-USER> (let ((some-var 304))
(defun some-fun () (+ some-var 100))(setf some-var 4)(funcall #'some-fun))
104
;; Alt-. on DEFUN brings you to "defboot.lisp"(defmacro-mundanely defun (&environment env name args &body body)(multiple-value-bind (forms decls doc) (parse-body body)
(let* ((lambda-guts `(,args ...))(lambda `(lambda ,@lambda-guts)) ...
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp44
![Page 45: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/45.jpg)
Artificial Intelligence
ClosuresCounterCL-USER> (defun increment-counter ()
(let ((counter 0))(incf counter)))
(increment-counter)(increment-counter)
1CL-USER> (defun increment-counter-closure ()
(let ((counter 0))(lambda () (incf counter))))
INCREMENT-COUNTER-CLOSURECL-USER> (let ((function-object (increment-counter-closure)))
(format t "counting: ~a ~a~%"(funcall function-object) (funcall function-object)))
counting: 1 2
Closure is a function that, in addition to its specific functionality, alsoencloses its lexical environment (environment as in, e.g., terminalenvironment variables).Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp45
![Page 46: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/46.jpg)
Artificial Intelligence
Closures [2]
Counter AgainCL-USER> (defun increment-counter-lambda ()
(let ((counter 0))(lambda (counter) (incf counter))))
INCREMENT-COUNTER-LAMBDACL-USER> (let ((function-object (increment-counter-lambda)))
(format t "counter: ~a~%" (funcall function-object 0))(format t "once more: ~a~%" (funcall function-object 0)))
counter: 1once more: 1CL-USER> (let ((function-object (increment-counter-closure)))
(format t "counter: ~a~%" (funcall function-object))(setf counter 0)(format t "counter: ~a~%" (funcall function-object)))
counter: 1counter: 2
Encapsulation!Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp46
![Page 47: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/47.jpg)
Artificial Intelligence
Lexical Variables [4]
Riddle #2CL-USER> (let ((lex 'initial-value))
(defun return-lex ()lex)
(defun return-lex-arg (lex)(return-lex))
(format t "return-lex: ~a~%"(return-lex))
(format t "return-lex-arg: ~a~%"(return-lex-arg 'new-value))
(format t "return-lex again: ~a~%"(return-lex)))
?
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp47
![Page 48: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/48.jpg)
Artificial Intelligence
Lexical Variables [4]
Riddle #2CL-USER> (let ((lex 'initial-value))
(defun return-lex ()lex)
(defun return-lex-arg (lex)(return-lex))
(format t "return-lex: ~a~%"(return-lex))
(format t "return-lex-arg: ~a~%"(return-lex-arg 'new-value))
(format t "return-lex again: ~a~%"(return-lex)))
; caught STYLE-WARNING:; The variable LEX is defined but never used.return-lex: INITIAL-VALUEreturn-lex-arg: INITIAL-VALUEreturn-lex again: INITIAL-VALUE
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp48
![Page 49: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/49.jpg)
Artificial Intelligence
Dynamic Variables
Riddle #3CL-USER> (defvar dyn 'initial-value)CL-USER> (defun return-dyn ()
dyn)CL-USER> (defun return-dyn-arg (dyn)
(return-dyn))CL-USER>(format t "return-dyn: ~a~%"
(return-dyn))(format t "return-dyn-arg: ~a~%"
(return-dyn-arg 'new-value))(format t "return-dyn again: ~a~%"
(return-dyn))?
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp49
![Page 50: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/50.jpg)
Artificial Intelligence
Dynamic Variables
Riddle #3CL-USER> (defvar dyn 'initial-value)CL-USER> (defun return-dyn ()
dyn)CL-USER> (defun return-dyn-arg (dyn)
(return-dyn))CL-USER>(format t "return-dyn: ~a~%"
(return-dyn))(format t "return-dyn-arg: ~a~%"
(return-dyn-arg 'new-value))(format t "return-dyn again: ~a~%"
(return-dyn))return-dyn: INITIAL-VALUEreturn-dyn-arg: NEW-VALUEreturn-dyn again: INITIAL-VALUE
defvar and defparameter create dynamically-bound variables.Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp50
![Page 51: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/51.jpg)
Artificial Intelligence
Currying
Back to GeneratorsCL-USER> (let ((x^10-lambda (lambda (x) (expt x 10))))
(dolist (elem '(2 3))(format t "~a^10 = ~a~%" elem (funcall x^10-lambda elem))))
2^10 = 10243^10 = 59049;; The following only works with roslisp_repl. Otherwise do first:;; (pushnew #p"/.../alexandria" asdf:*central-registry* :test #'equal)CL-USER> (asdf:load-system :alexandria)CL-USER> (dolist (elem '(2 3))
(format t "~a^10 = ~a~%"elem (funcall (alexandria:curry #'expt 10) elem)))
2^10 = 1003^10 = 1000CL-USER> (dolist (elem '(2 3))
(format t "~a^10 = ~a~%"elem (funcall (alexandria:rcurry #'expt 10) elem)))
2^10 = 10243^10 = 59049Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp51
![Page 52: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/52.jpg)
Artificial Intelligence
Guidelines
• Don’t use global variables! Only for constants.• If your function generates side-effects, name it correspondingly (eitherfoo! which is preferred, or foof as in setf, or nfoo as in nconc)
• Use Ctrl-Alt-\ on a selected region to fix indentation• Try to keep the brackets all together:
This looks weird in Lisp(if condition
do-thisdo-that)
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp52
![Page 53: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/53.jpg)
Artificial Intelligence
Links
• Alexandria documentation:http://common-lisp.net/project/alexandria/draft/alexandria.html
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp53
![Page 54: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/54.jpg)
Artificial Intelligence
Outline
Background
Theory
Organizational
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp54
![Page 55: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/55.jpg)
Artificial Intelligence
Info Summary
• Assignment code: REPO/assignment_3/src/...• Assignment points: 10 out of 50• Assignment due: 26.04, Tuesday, 08:00 AM German time• Next class: 26.04, 16:15
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp55
![Page 56: Robot Programming with Lisp - 3. Functional Programming ... · Artificial Intelligence RobotProgrammingwithLisp 3. Functional Programming: Functions, Lexical Scope and Closures GayaneKazhoyan](https://reader034.fdocuments.us/reader034/viewer/2022042223/5ec98229565d3e44ea2a4fea/html5/thumbnails/56.jpg)
Artificial Intelligence
Q & A
Thanks for your attention!
Background Theory Organizational
Gayane Kazhoyan
19th April, 2016
Robot Programming with Lisp56