cs 363 comparative programming languages functional languages: scheme
TRANSCRIPT
![Page 1: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/1.jpg)
CS 363 Comparative Programming Languages
Functional Languages: Scheme
![Page 2: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/2.jpg)
CS 363 Spring 2005 GMU 2
Fundamentals of Functional Programming Languages
• The objective of the design of a functional programming language (FPL) is to mimic mathematical functions to the greatest extent possible
• The basic process of computation is fundamentally different in a FPL than in an imperative language– In an imperative language, operations are done and the results are
stored in variables for later use– Management of variables is a constant concern and source of
complexity for imperative programming
• In an FPL, variables are not necessary, as is the case in mathematics
![Page 3: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/3.jpg)
CS 363 Spring 2005 GMU 3
Fundamentals of Functional Programming Languages
• In an FPL, the evaluation of a function always produces the same result given the same parameters– This is called referential transparency
![Page 4: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/4.jpg)
CS 363 Spring 2005 GMU 4
Functions
• A function is a rule that associates to each x from some set X of values a unique y from another set Y of values:– y = f(x) or f: X Y
• Functional Forms– Def: A higher-order function, or functional form, is one
that either takes functions as parameters, yields a function as its result, or both
domainrange
![Page 5: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/5.jpg)
CS 363 Spring 2005 GMU 5
Lisp
• Lisp – based on lambda calculus (Church)– Uniform representation of programs and data
using single general data structure (list)– Interpreter based (written in Lisp)– Automatic memory management– Evolved over the years– Dialects: COMMON LISP, Scheme
![Page 6: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/6.jpg)
CS 363 Spring 2005 GMU 6
Scheme
(define (gcd u v) (if ( = v 0) u (gcd v (remainder u v)) ))
(define (reverse l) (if (null? l) l (append (reverse (cdr l))(list (car l))) ))
![Page 7: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/7.jpg)
CS 363 Spring 2005 GMU 7
Introduction to Scheme
• A mid-1970s dialect of LISP, designed to be a cleaner, more modern, and simpler version than the contemporary dialects of LISP
• Uses only static scoping• Functions are first-class entities
– They can be the values of expressions and elements of lists
– They can be assigned to variables and passed as parameters
![Page 8: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/8.jpg)
CS 363 Spring 2005 GMU 8
Scheme
(define (gcd u v) (if ( = v 0) u (gcd v (remainder u v)) ))
• Once defined in the interpreter: (gcd 25 10) 5
![Page 9: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/9.jpg)
CS 363 Spring 2005 GMU 9
Scheme Syntax
expression atom | listatom number | string
| identifier | character | booleanlist ‘(‘ expression-sequence ‘)’expression-sequence expression
| expression-sequence expression
simplest elements
![Page 10: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/10.jpg)
CS 363 Spring 2005 GMU 10
Scheme atoms
• Constants:– numbers, strings, #T = True, …
• Identifier names:
• Function/operator names– pre-defined & user defined
![Page 11: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/11.jpg)
CS 363 Spring 2005 GMU 11
Scheme Expression vs. C
In Scheme:(+ 3 (* 4 5 ))
(and (= a b)(not (= a 0)))
(gcd 10 35)
In C:3 + 4 * 5
(a = = b) && (a != 0)
gcd(10,35)
![Page 12: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/12.jpg)
CS 363 Spring 2005 GMU 12
Evaluation Rules for Scheme Expressions
1. Constant atoms (numbers, strings) evaluate to themselves
2. Identifiers are looked up in the current environment and replaced by the value found there (using dynamically maintained symbol table)
3. A list is evaluated by recursively evaluating each element in the list as an expression; the first expression must evaluate to a function. The function is applied to the evaluated values of the rest of the list.
![Page 13: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/13.jpg)
CS 363 Spring 2005 GMU 13
Scheme Evaluation
To evaluate (* (+ 2 3)(+ 4 5))1. * is the function – must evaluate the two
expressions (+ 2 3) and (+ 4 5)2. To evaluate (+ 2 3)
1. + is the function – must evaluation the two expressions 2 and 3
2. 2 evaluates to the integer 23. 3 evaluates to the integer 34. + 2 3 = 5
3. To evaluate (+ 4 5) follow similar steps4. * 5 9 = 45
*
+ +
2 3 4 5
![Page 14: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/14.jpg)
CS 363 Spring 2005 GMU 14
Scheme Conditionals
If statement:
(if ( = v 0)
u
(gcd v (remainder u v))
)
(if (= a 0) 0 (/ 1 a))
Cond statement:(cond (( = a 0) 0)
((= a 1) 1)
(else (/ 1 a))
)
Both if and cond functions usedelayed evaluation for the expressions in their bodies (i.e. (/ 1 a) is not evaluated unlessthe appropriate branch is chosen).
![Page 15: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/15.jpg)
CS 363 Spring 2005 GMU 15
Example of COND
(DEFINE (compare x y) (COND ((> x y) (DISPLAY “x is greater than y”)) ((< x y) (DISPLAY “y is greater than x”)) (ELSE (DISPLAY “x and y are equal”)) ) )
![Page 16: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/16.jpg)
CS 363 Spring 2005 GMU 16
Predicate Functions
1. EQ? takes two symbolic parameters; it returns #T if both parameters are atoms and the two are the same
e.g., (EQ? 'A 'A) yields #T
(EQ? 'A '(A B)) yields ()– Note that if EQ? is called with list parameters, the result
is not reliable– EQ? does not work for numeric atoms (use = )
![Page 17: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/17.jpg)
CS 363 Spring 2005 GMU 17
Predicate Functions2. LIST? takes one parameter; it returns #T if the
parameter is a list; otherwise()
3. NULL? takes one parameter; it returns #T if the parameter is the empty list; otherwise()
Note that NULL? returns #T if the parameter is()
4. Numeric Predicate Functions
=, <>, >, <, >=, <=, EVEN?, ODD?, ZERO?, NEGATIVE?
![Page 18: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/18.jpg)
CS 363 Spring 2005 GMU 18
let function
• Allows values to be given temporary names within an expression– (let ((a 2 ) (b 3)) ( + a b))– 5
• Semantics: Evaluate all expressions, then bind the values to the names; evaluate the body
![Page 19: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/19.jpg)
CS 363 Spring 2005 GMU 19
Quote (‘) function• A list that is preceeded by QUOTE or a quote mark (‘) is
NOT evaluated.• QUOTE is required because the Scheme interpreter, named EVAL, always evaluates parameters to function applications before applying the function. QUOTE is used to avoid parameter evaluation when it is not appropriate– QUOTE can be abbreviated with the apostrophe prefix operator
• Can be used to provide function arguments– (myfunct ‘(a b) ‘(c d))
![Page 20: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/20.jpg)
CS 363 Spring 2005 GMU 20
Output functions
• Output Utility Functions:
(DISPLAY expression)
(NEWLINE)
![Page 21: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/21.jpg)
CS 363 Spring 2005 GMU 21
define function
Form 1: Bind a symbol to a expression:
(define a 2)
(define emptylist ‘( ))
(define pi 3.141593)
![Page 22: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/22.jpg)
CS 363 Spring 2005 GMU 22
define function
Form 2: To bind names to lambda expressions
define (cube x) (* x (* x x )))
(define (gcd u v) (if ( = v 0) u (gcd v (remainder u v)) ))
function name and parameters
function body – lambda expression
![Page 23: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/23.jpg)
CS 363 Spring 2005 GMU 23
Function Evaluation
• Evaluation process (for normal functions): 1. Parameters are evaluated, in no particular order
2. The values of the parameters are substituted into the function body
3. The function body is evaluated
4. The value of the last expression in the body is the value of the function
(Special forms use a different evaluation process)
![Page 24: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/24.jpg)
CS 363 Spring 2005 GMU 24
Data Structures in Scheme: Box Notation for Lists
first element (car) rest of list (cdr)
1
List manipulation is typically written using ‘car’ and ‘cdr’
![Page 25: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/25.jpg)
CS 363 Spring 2005 GMU 25
Data Structures in Scheme
1 2 3 (1,2,3)
c
da
b((a b) c (d))
![Page 26: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/26.jpg)
CS 363 Spring 2005 GMU 26
Basic List Manipulation
• (car L) – returns the first element of L
• (cdr L) – returns L minus the first element
(car ‘(1 2 3)) = 1
(car ‘((a b)(c d))) = (a b)
(cdr ‘(1 2 3)) = (2 3)
(cdr ‘((a b)(c d))) = ((c d))
![Page 27: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/27.jpg)
CS 363 Spring 2005 GMU 27
Basic List Manipulation
• (list e1 … en) – return the list created from the individual elements
• (cons e L) – returns the list created by adding expression e to the beginning of list L
(list 2 3 4) = (2 3 4)
(list ‘(a b) x ‘(c d) ) = ((a b)x(c d))
(cons 2 ‘(3 4)) = (2 3 4)
(cons ‘((a b)) ‘(c)) = (((a b)) c)
![Page 28: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/28.jpg)
CS 363 Spring 2005 GMU 28
Example Functions
1. member - takes an atom and a simple list; returns #T if the atom is in the list; () otherwise
(DEFINE (member atm lis) (COND ((NULL? lis) '()) ((EQ? atm (CAR lis)) #T) ((ELSE (member atm (CDR lis))) ))
![Page 29: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/29.jpg)
CS 363 Spring 2005 GMU 29
Example Functions2. equalsimp - takes two simple lists as parameters;
returns #T if the two simple lists are equal; () otherwise
(DEFINE (equalsimp lis1 lis2) (COND ((NULL? lis1) (NULL? lis2)) ((NULL? lis2) '()) ((EQ? (CAR lis1) (CAR lis2)) (equalsimp(CDR lis1)(CDR lis2))) (ELSE '())))
![Page 30: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/30.jpg)
CS 363 Spring 2005 GMU 30
Example Functions3. equal - takes two general lists as parameters; returns #T if the two
lists are equal; ()otherwise(DEFINE (equal lis1 lis2) (COND ((NOT (LIST? lis1))(EQ? lis1 lis2)) ((NOT (LIST? lis2)) '()) ((NULL? lis1) (NULL? lis2)) ((NULL? lis2) '()) ((equal (CAR lis1) (CAR lis2)) (equal (CDR lis1) (CDR lis2))) (ELSE '())))
![Page 31: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/31.jpg)
CS 363 Spring 2005 GMU 31
Example Functions
(define (count L)
(if (null? L) 0
(+ 1 (count (cdr L)))
)
)
(count ‘( a b c d)) =
(+ 1 (count ‘(b c d))) =
(+ 1 (+ 1(count ‘(c d))))
(+ 1 (+ 1 (+ 1 (count ‘(d)))))=
(+ 1 (+ 1 (+ 1 (+ 1 (count ‘())))))=
(+ 1 (+ 1 (+ 1 (+ 1 0))))= 4
![Page 32: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/32.jpg)
CS 363 Spring 2005 GMU 32
Scheme Functions
Now define(define (count1 L) ??
)
so that (count1 ‘(a (b c d) e)) = 5
![Page 33: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/33.jpg)
CS 363 Spring 2005 GMU 33
Scheme Functions
This function counts the individual elements:
(define (count1 L)
(cond ( (null? L) 0 )
( (list? (car L))
(+ (count1 (car L))(count1 (cdr L))))
(else (+ 1 (count (cdr L))))
)
)
so that (count1 ‘(a (b c d) e)) = 5
![Page 34: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/34.jpg)
CS 363 Spring 2005 GMU 34
Example Functions
(define (append L M)
(if (null? L) M
(cons (car L)(append(cdr L) M))
)
)
(append ‘(a b) ‘(c d)) = (a b c d)
![Page 35: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/35.jpg)
CS 363 Spring 2005 GMU 35
How does append do its job?
(define (append L M)
(if (null? L) M
(cons (car L)(append(cdr L) M))))
(append ‘(a b) ‘(c d)) =
(cons a (append ‘(b) ‘(c d))) =
![Page 36: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/36.jpg)
CS 363 Spring 2005 GMU 36
How does append do its job?
(define (append L M)
(if (null? L) M
(cons (car L)(append(cdr L) M))))
(append ‘(a b) ‘(c d)) =
(cons a (append ‘(b) ‘(c d))) =
(cons a (cons b (append ‘() ‘(c d)))) =
![Page 37: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/37.jpg)
CS 363 Spring 2005 GMU 37
How does append do its job?
(define (append L M) (if (null? L) M (cons (car L)(append(cdr L) M))))
(append ‘(a b) ‘(c d)) =(cons a (append ‘(b) ‘(c d))) =
(cons a (cons b (append ‘() ‘(c d)))) =(cons a (cons b ‘(c d))) =
![Page 38: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/38.jpg)
CS 363 Spring 2005 GMU 38
How does append do its job?
(define (append L M)
(if (null? L) M
(cons (car L)(append(cdr L) M))))
(append ‘(a b) ‘(c d)) =
(cons a (append ‘(b) ‘(c d))) =
(cons a (cons b (append ‘() ‘(c d)))) =
(cons a (cons b ‘(c d))) =
(cons a ‘(b c d)) =
![Page 39: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/39.jpg)
CS 363 Spring 2005 GMU 39
How does append do its job?
(define (append L M)
(if (null? L) M
(cons (car L)(append(cdr L) M))))
(append ‘(a b) ‘(c d)) =
(cons a (append ‘(b) ‘(c d))) =
(cons a (cons b (append ‘() ‘(c d)))) =
(cons a (cons b ‘(c d))) =
(cons a ‘(b c d)) =
(a b c d)
![Page 40: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/40.jpg)
CS 363 Spring 2005 GMU 40
Reverse
Write a function that takes a list of elements and reverses it:
(reverse ‘(1 2 3 4)) = (4 3 2 1)
![Page 41: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/41.jpg)
CS 363 Spring 2005 GMU 41
Reverse
(define (reverse L)
(if (null? L) ‘()
(append (reverse (cdr L))(list (car L)))
)
)
![Page 42: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/42.jpg)
CS 363 Spring 2005 GMU 42
Selection Sort in Scheme
Let’s define a few useful functions first:(DEFINE (findsmallest lis small) (COND ((NULL? lis) small) ((< (CAR lis) small) (findsmallest (CDR lis) (CAR lis))) (ELSE (findsmallest (CDR lis) small)) ) )
![Page 43: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/43.jpg)
CS 363 Spring 2005 GMU 43
Selection Sort in Scheme
(DEFINE (remove lis item) (COND ((NULL? lis) ‘() ) ((= (CAR lis) item) lis) (ELSE (CONS (CAR lis) (remove (CDR lis)
item))) ))
Cautious programming!
Assuming integers
![Page 44: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/44.jpg)
CS 363 Spring 2005 GMU 44
Selection Sort in Scheme
(DEFINE (selectionsort lis)
(IF (NULL? lis) lis
(LET ((s (findsmallest (CDR lis) (CAR lis))))
(CONS s (selectionsort (remove lis s)) )
)
)
![Page 45: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/45.jpg)
CS 363 Spring 2005 GMU 45
Higher order functions
• Def: A higher-order function, or functional form, is one that either takes functions as parameters, yields a function as its result, or both
• Mapcar
• Eval
![Page 46: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/46.jpg)
CS 363 Spring 2005 GMU 46
Higher-Order Functions: mapcar
Apply to All - mapcar - Applies the given function to all elements of the
given list; result is a list of the results
(DEFINE (mapcar fun lis) (COND ((NULL? lis) '()) (ELSE (CONS (fun (CAR lis)) (mapcar fun (CDR lis)))) ))
![Page 47: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/47.jpg)
CS 363 Spring 2005 GMU 47
Higher-Order Functions: mapcar
• Using mapcar:(mapcar (LAMBDA (num) (* num num num)) ‘(3 4 2 6))
returns (27 64 8 216)
![Page 48: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/48.jpg)
CS 363 Spring 2005 GMU 48
Higher Order Functions: EVAL
• It is possible in Scheme to define a function that builds Scheme code and requests its interpretation
• This is possible because the interpreter is a user-available function, EVAL
![Page 49: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/49.jpg)
CS 363 Spring 2005 GMU 49
Using EVAL for adding a List of Numbers
Suppose we have a list of numbers that must be added:(DEFINE (adder lis) (COND((NULL? lis) 0) (ELSE (+ (CAR lis) (adder(CDR lis ))))))
Using Eval((DEFINE (adder lis) (COND ((NULL? lis) 0) (ELSE (EVAL (CONS '+ lis)))))
(adder ‘(3 4 5 6 6))Returns 24
![Page 50: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/50.jpg)
CS 363 Spring 2005 GMU 50
Other Features of Scheme• Scheme includes some imperative features:
1. SET! binds or rebinds a value to a name
2. SET-CAR! replaces the car of a list
3. SET-CDR! replaces the cdr part of a list
![Page 51: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/51.jpg)
CS 363 Spring 2005 GMU 51
COMMON LISP
• A combination of many of the features of the popular dialects of LISP around in the early 1980s
• A large and complex language – the opposite of Scheme
![Page 52: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/52.jpg)
CS 363 Spring 2005 GMU 52
COMMON LISP
• Includes:– records
– arrays
– complex numbers
– character strings
– powerful I/O capabilities
– packages with access control
– imperative features like those of Scheme
– iterative control statements
![Page 53: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/53.jpg)
CS 363 Spring 2005 GMU 53
ML
• A static-scoped functional language with syntax that is closer to Pascal than to LISP
• Uses type declarations, but also does type inferencing to determine the types of undeclared variables
• It is strongly typed (whereas Scheme is essentially typeless) and has no type coercions
• Includes exception handling and a module facility for implementing abstract data types
![Page 54: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/54.jpg)
CS 363 Spring 2005 GMU 54
ML
• Includes lists and list operations• The val statement binds a name to a value
(similar to DEFINE in Scheme)• Function declaration form:
fun function_name (formal_parameters) =
function_body_expression;
e.g.,
fun cube (x : int) = x * x * x;
![Page 55: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/55.jpg)
CS 363 Spring 2005 GMU 55
Haskell
• Similar to ML (syntax, static scoped, strongly typed, type inferencing)
• Different from ML (and most other functional languages) in that it is purely functional (e.g., no variables, no assignment statements, and no side effects of any kind)
![Page 56: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/56.jpg)
CS 363 Spring 2005 GMU 56
Haskell
• Most Important Features– Uses lazy evaluation (evaluate no
subexpression until the value is needed)– Has list comprehensions, which allow it to deal
with infinite lists
![Page 57: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/57.jpg)
CS 363 Spring 2005 GMU 57
Haskell Examples
1. Fibonacci numbers (illustrates function definitions with different parameter forms)
fib 0 = 1
fib 1 = 1
fib (n + 2) = fib (n + 1)
+ fib n
![Page 58: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/58.jpg)
CS 363 Spring 2005 GMU 58
Haskell Examples
2. Factorial (illustrates guards)
fact n
| n == 0 = 1
| n > 0 = n * fact (n - 1)
The special word otherwise can appear as a guard
![Page 59: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/59.jpg)
CS 363 Spring 2005 GMU 59
Haskell Examples3. List operations
– List notation: Put elements in brackets
e.g., directions = [“north”, “south”, “east”, “west”]
– Length: #
e.g., #directions is 4– Arithmetic series with the .. operator
e.g., [2, 4..10] is [2, 4, 6, 8, 10]
![Page 60: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/60.jpg)
CS 363 Spring 2005 GMU 60
Haskell Examples
3. List operations (cont)– Catenation is with ++
e.g., [1, 3] ++ [5, 7] results in
[1, 3, 5, 7]– CONS, CAR, CDR via the colon operator (as in
Prolog)
e.g., 1:[3, 5, 7] results in
[1, 3, 5, 7]
![Page 61: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/61.jpg)
CS 363 Spring 2005 GMU 61
Haskell Examples
• Quicksort:
sort [] = []
sort (a:x) = sort [b | b ← x; b <= a]
++ [a] ++
sort [b | b ← x; b > a]
![Page 62: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/62.jpg)
CS 363 Spring 2005 GMU 62
Applications of Functional Languages
• LISP is used for artificial intelligence– Knowledge representation– Machine learning– Natural language processing– Modeling of speech and vision
• Scheme is used to teach introductory programming at a significant number of universities
![Page 63: CS 363 Comparative Programming Languages Functional Languages: Scheme](https://reader035.vdocuments.net/reader035/viewer/2022062722/56649f275503460f94c3f79b/html5/thumbnails/63.jpg)
CS 363 Spring 2005 GMU 63
Comparing Functional and Imperative Languages
• Imperative Languages:– Efficient execution– Complex semantics– Complex syntax– Concurrency is programmer designed
• Functional Languages:– Simple semantics– Simple syntax– Inefficient execution– Programs can automatically be made concurrent