A Scheme: "Small" Variant of Lisp 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
Overview
Dr Scheme Characters, Atoms & Strings Functions: Math & predicates Constants: Quoting More functions: List construction Defining variables Flow of control Defining functions
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
Characters, Atoms & Strings
Characters are: A...Z, a...z, 0...9, ! % $ * + - / = ? Atom
String of one or more characters with no spaces between; Examples: 123, 1xyz, fred (aka: symbol) #\ used for character constants
E.g., #\A
Special characters: #\newline #t, #f (true, false) Upper/lower case only distinguished in constants
Strings
Double quoted sequences of characters "this is a string"
Math
Form of function application is prefix Syntax: operator value1 value2 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)))
"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
Predicates: Functions returning boolean values
Often named ending with "?"
Built-in predicate examples
equal? test for equality (works with lists) boolean? test for boolean type object integer? test for integer type object string=? test if two strings are equal
(equal? 10 3) #f (equal? 4 4) #t (boolean? #f) #t (integer? 5) #t (string=? "abc" "ABC") #f
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
Quoted Symbols
Not the same as double quoted characters Normally, Scheme tries to evaluate symbols as functions Often need to put a single leading quote to tell it not to evaluate It strips the quote away as evaluation `abc abc `1bigthing 1bigthing `123 123 123 123
Some Conversion Functions
Convert from number to string
(number->string 123) "123" (number->string 12.3) 12.3
Convert from string to number
(string->number "123") 123 (string->number "12.3") 12.3
Convert from string to symbol
(string->symbol "abc") abc
Convert from symbol to string
(symbol->string 'abc) "abc"
Defining & using variables
(define x 1)
defines variable x to have value 1
> (define a 4) >a 4 a4 (+ a 6) 10
Lists
Lists
() is the empty list; `() is the quoted empty list Lists are fully parenthesized and contain lists and/or sequences of atoms/symbols
Often need to quote lists to pass as parameters to functions
E.g., want to 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
Functions Operating on lists
(member op1 op2) if op1 is a list element of op2, return sublist of op2 starting with op1; else return #f (member `a `(a)) (a) (member `1 `(+ 1 2)) (1 2) (member `- `(+ 1 2)) #f (member `1 `((1 2) (2 3))) #f
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)) (cdr a `(a b)) (b) (cons `a `(b c)) (a b c)
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) `())
List construction functions-2
More list functions & predicates caar: (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
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)
Define-struct: Dr. Scheme
Syntax: (define-struct name (field1 field2 ...)) Make new structs: make-name Get elements: name-field1, 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
Conditional Evaluation
Syntax: (cond
[bool-condition1 expr1] [bool-condition2 expr2] ... [else default-expr] ; optional )
Semantics: Evaluates the boolean conditions from top to bottom. In the case where one of these conditions evaluates to true, the result of the "cond" is its corresponding expression. Otherwise, the result of the cond is the default-expr. (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)
Functions-1: Lambda Expressions
The creation of procedure objects Syntax: (lambda (op1 op2 ...opN) (expression)) Semantics: Creates a procedure that has N formal parameters or arguments; expression can have references to these parameters; the result of calling the function is the result of evaluating the expression with the particular actual parameters substituted into the formal parameters.
(lambda (init-state) ; anonymous function (cond [(null? init-state) init-state] [else (car init-state)] ) ) #<procedure> >
Functions-2: Supplying Parameters
Syntax: (<function> op1 op2 ... opN) Semantics: <function> can be a function name, or a lambda expression giving an anonymous function. <function> is evaluated with the given N parameters.
( list ; the function `(a) ; the parameter ) ( (lambda (init-state) (cond [(null? init-state) init-state] [else (car init-state)] ) ) ; the function '(a) ; the parameter
Functions-3: Name Binding
Usually want to name our functions
Anonymous functions can only be used once, in the text, since we don't have a name for them, we can't call them again
Syntax: Similar to variables
(define <function...