1
Scheme
A “small” variant of Lisp
2
Basics
• Why Lisp?– Learning lisp in the study of AI is like learning
French if you are going to France (Charniak & McDermot)
• Interpreted language
• Prefix operator notation, with parentheses
• Functional style
3
Overview
• Dr Scheme• Atoms & Lists• Functions: Math & predicates• Constants: Quoting• More functions: List construction• Defining variables• Flow of control• Defining functions
4
Dr. Scheme
• See web site for downloads• Has different language levels:
– “Language”• “Choose Language”
– “Full Scheme”
• Two windows– Top: program editing (“definitions”) window
• Define functions, variables, comments
– Bottom: interactive evaluation window: interpreted• Evaluate functions, test code
5
Atoms & Lists
• Characters are: A…Z, a…z, 0…9, ! % $ * + - / = ?• Atom
– String of one or more characters with no spaces between; Examples: 123, 1xyz, fred
• #\ used for character constants; e.g., #\newline• #t, #f (true, false)• Upper/lower case only distinguished in constants
6
Math
• Form of function application is prefixSyntax: operator value value
• Expressions are parenthesized, e.g.,(+ 1 2)
• Math operators: + - / *; other examples:– Other examples: abs, sqrt, modulo, remainder
• Nested expressions often used:(abs (* (- 2 3) (- 0 1)))
7
“Interactions” window
> (+ 3 4)
7
>
> (+ (- 6 3) 10)
WARNING: Interactions window is out of sync with the definitions window. Click Execute.
13 Notation: (+ (- 6 3) 10) 13
8
Predicates: Functions returning boolean values
• Often named ending with “?”equal? – test for equality (works with lists)
boolean? – test for boolean type object
integer? – test for integer type object
(equal? 10 3) #f
(equal? 4 4) #t
(boolean? #f) #t
9
Relational operators and functions
(> op1 op2) – test if op1 > op2
(< op1 op2) – test if op1 < op2
(= op1 op2) – numeric equality test
(>= op1 op2)
(<= op1 op2)
(not op1) – negate the boolean operand
(and op1 op2) – boolean conjunction
(or op1 op2) – boolean disjunction
10
Defining & using variables
(define x 1)– defines variable x to have value 1
> (define a 4)
> a
4
a 4
(+ a 6) 10
11
Lists
• Lists() is the empty listLists are fully parenthesized and contain lists and/or sequences
of atoms
• Often need to quote lists to pass as parameters to functions• E.g., test if two lists “(+ 1 2)” and “(+ 2 1)” are equal
(equal? (+ 1 2) (+ 2 1)) #t• Quote the lists so that they are not evaluated
(equal? ‘(+ 1 2) ‘(+ 2 1)) #f
• Quotes just need single quote in front of list
12
Functions for lists
(member op1 op2) – if op1 is a list element of op2, return sublist of op2 starting with op1; else return #f
(member ‘1 ‘(+ 1 2)) (1 2)
(member ‘- ‘(+ 1 2)) #f
(member ‘1 ‘((1 2) (2 3))) #f
13
List construction functions-1
(list op1 op2 …) - form a list from a sequence of items
(append op1 op2 …) – put elements of lists in a new list
(car op) - return the head element of a list op(cdr op) - return the tail of a list op, as a list(cons op1 op2) - make new list with op1 on front of op2
(list ‘a ‘b ‘c) (a b c)(append '(a) '(b)) (a b)(car ‘(a b)) a(cdr ‘(a b)) (b)(cons ‘a ‘(b c)) (a b c)
14
Exercise-1
(list ‘(a) ‘b))
(append ‘(a b c) ‘(1 2 3)) (car (list ‘a ‘b ‘c)) (cdr ‘((a b) c)) (cdr ‘(a)) (cons ‘a ‘((b))) (cons ‘(a) ‘())
15
List construction functions-2
• More list functions & predicatescaar: (car (car x))cadr: (car (cdr x))caddr: (car (cdr (cdr x)))
etc (up to 4 operators in a sequence)(null? ‘()) #t(null? ‘(a b c)) #f(null? (cdr ‘(a))) #t
16
Defining list variables
(define y ‘(a b c))
y (a b c)(define init-state ‘((blank 5 4) (6 1 8) (7 3 2)))
(car init-state) (blank 5 4)
17
Define-struct: Dr. Scheme
Syntax: (define-struct name (field1 field2 …))
Make new structs: make-name
Get elements: name-field2, name-field2…
(define-struct row (left middle right))
(define row1 (make-row ‘blank 1 8))
(row-left row1) blank
(row-middle row1) 1
(row-right row1) 8
18
Conditional evaluation
Syntax: (cond[bool-condition1 expr1][bool-condition2 expr2]…[else default-expr] ; optional
)(define init-state ‘((blank 5 4) (6 1 8) (7 3 2)))
(cond[(null? init-state) init-state][else (car init-state)]
) (blank 5 4)
19
Functions-1
• Use “lambda expressions”• Syntax: (lambda (op1 op2 …) (expression))
(lambda (init-state) (cond
[(null? init-state) init-state][else (car init-state)]
))#<procedure>>
20
Functions-2: Supplying parameters
(list ‘(a)) ; typical function usage( list ; the function ‘(a) ; the parameter)( (lambda (init-state)
(cond [(null? init-state) init-state] [else (car init-state)]
) ) ; the function
'(a) ; the parameter)
21
Functions-3
• Usually want to name our functions– These have been “anonymous” functions
(define ourFun (lambda (arg)
(cond [(null? arg) arg] [else (car arg)]) ; end cond
) ; end lambda) ; end define(ourFun '(a)) a
22
Exercise-2
• Write a function to return –1, 0, +1 depending on two parameters a and ba < b return –1
a > b return +1
a = b return 0
23
Recursion: Control structure in functional programming
• Count the number of elements in a list(define list-length (lambda (myList) (cond [(null? myList) 0] [else
(+ 1 (list-length (cdr myList)) )]
) ; end cond ) ; end lambda) ; end list-length
24
Recursive list reverse
(define list-reverse (lambda (myList) (cond [(null? myList) myList] [else (append
(list-reverse (cdr myList))(list (car myList))
)] ; end else
) ; end cond ) ; end lambda) ; end list-reverse
25
Non-negative integer multiply through repeated addition
(define int-mult (lambda (x y) (cond [(equal? y 0) 0] [(equal? x 0) 0] [(equal? y 1) x] [else
(+ x(int-mult x (- y 1))
)] ; end else
) ; end cond ) ; end lambda ) ; end int-mult