Chapter 15
Functional
Programming
Languages
ISBN 0-321-33025-0
Chapter 15 Topics
•
•
•
•
•
•
•
•
•
•
Introduction
Mathematical Functions
Fundamentals of Functional Programming Languages
The First Functional Programming Language: LISP
Introduction to Scheme
COMMON LISP
ML & Haskell – not covered
Closures – Added Topic
Applications of Functional Languages
Comparison of Functional and Imperative Languages
Copyright © 2006 Addison-Wesley. All rights reserved.
1-2
Why study functional languages?
Without understanding functional
programming, you can’t invent MapReduce,
the algorithm that makes Google so massively
scalable.
—Joel Spolsky, The Perils of Java Schools
Copyright © 2006 Addison-Wesley. All rights reserved.
Introduction
• The design of the imperative languages is
based directly on the von Neumann
architecture
– Efficiency is the primary concern, rather than the
suitability of the language for software
development
• The design of the functional languages is
based on mathematical functions
– A solid theoretical basis that is also closer to the
user, but relatively unconcerned with the
architecture of the machines on which programs
will run
Copyright © 2006 Addison-Wesley. All rights reserved.
1-4
Backus – 1978 Turing Award lecture
• Made a case for pure functional languages
– more readable, more reliable, more likely to be
correct
– meaning of expressions are independent of their
context (no side effects)
• Proposed pure functional language FP
Copyright © 2006 Addison-Wesley. All rights reserved.
1-5
Fundamentals of Functional Programming Languages
• The objective of the design of a 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
* Scheme not pure – we will use some variables, but minimal compared to imperative
Copyright © 2006 Addison-Wesley. All rights reserved.
1-6
Referential Transparency
• In an FPL, the evaluation of a function
always produces the same result given the
same parameters
• Means the expression can be replaced with
its result without changing the meaning of
the program (true because no side effects;
must be determinate)
• Semantics of purely functional languages
are therefore simpler than imperative
languages
Copyright © 2006 Addison-Wesley. All rights reserved.
1-7
Mathematical Functions
• A mathematical function is a mapping of
members of one set, called the domain set,
to another set, called the range set
• Mapping is described by an expression or
in some cases a table
• Evaluation order is controlled by recursion
and conditional expressions rather than by
sequencing and iteration
• A math function defines a value rather than
a sequence of operations on values in
memory. No variables, no side effects.
Copyright © 2006 Addison-Wesley. All rights reserved.
1-8
Lambda Expression
• A lambda expression specifies the
parameter(s) and the mapping of a function
in the following form
(x) x * x * x
for the function cube (x) = x * x * x
• Lambda expressions describe nameless
functions
Copyright © 2006 Addison-Wesley. All rights reserved.
1-9
Lambda Expressions
• Lambda expressions are applied to
parameter(s) by placing the parameter(s)
after the expression
e.g., ((x) x * x * x)(2)
which evaluates to 8
• Lambda expression may have more than
one parameter
Copyright © 2006 Addison-Wesley. All rights reserved.
1-10
Functional Forms
• A higher-order function, or functional
form, is one that:
– takes functions as parameters or
– yields a function as its result, or
– both
• Example outside programming: derivative
in calculus
Great for AI!
Copyright © 2006 Addison-Wesley. All rights reserved.
1-11
Function Composition
• A functional form that takes two functions
as parameters and yields a function whose
value is the first actual parameter function
applied to the application of the second
Form: h  f ° g
which means h (x)  f ( g ( x))
Example: f (x)  x + 2 and g (x)  3 * x,
h  f ° g yields (3 * x)+ 2
Copyright © 2006 Addison-Wesley. All rights reserved.
1-12
Apply-to-all
• A functional form that takes a single
function as a parameter and yields a list of
values obtained by applying the given
function to each element of a list of
parameters
Form: 
For h (x)  x * x
( h, (2, 3, 4)) yields (4, 9, 16)
Copyright © 2006 Addison-Wesley. All rights reserved.
1-13
LISP Data Types and Structures
• Originally, LISP was a typeless language
• Data object types: originally only atoms and
lists
– Atoms are either symbols (e.g., ‘count) or
numbers (e.g., 1, 2.5)
– List form: parenthesized collections of sublists
and/or atoms
‘(A B (C D) E)
‘(1 2 5)
Notice single quote, so list is not evaluated
Notice no commas: not (1, 2, 5)
Copyright © 2006 Addison-Wesley. All rights reserved.
1-14
LISP Lists
LISP lists are stored internally as single-linked lists
(A B C D)
A
B
C
D
(A (B C) D (E (F G))
D
A
B
C
E
F
Copyright © 2006 Addison-Wesley. All rights reserved.
G
LISP Interpretation
• Lambda notation is used to specify functions and
function definitions. Function applications and data
have the same form.
– If the list (A B C) is interpreted as data it is a simple list of
three atoms, A, B, and C
– If it is interpreted as a function application, it means that the
function named A is applied to the two parameters, B and C
• 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
Cool… very useful for AI!
Copyright © 2006 Addison-Wesley. All rights reserved.
1-16
Intro to Scheme
• We’ll use DrScheme (modern LISP)
• Language Pack: Swindle
Function definitions go here
Interpreter – try it!
Copyright © 2006 Addison-Wesley. All rights reserved.
Scheme Interpreter
• Interpreter is read-evaluate-write infinite
loop
• Expressions evaluated by EVAL function
– Parameters are evaluated, in no particular order
(literals EVAL to themselves)
– The values of the parameters are substituted into
the function body
– The function body is evaluated
– The value of the last expression in the body is
the value of the function
• (cube (+ 1 2))
Parameter (+ 1 2) is evaluated, passed to cube.
Result (9) is returned & displayed
Copyright © 2006 Addison-Wesley. All rights reserved.
1-18
Primitive Functions
REMEMBER THE ( ) around function calls!
Learn to read error messages, they will tell you
what the evaluator was attempting when the
error occurred.
Copyright © 2006 Addison-Wesley. All rights reserved.
1-19
Function Definition: LAMBDA
• A Scheme program is collection of function
definitions
• Pure form: Lambda Expressions
– Form is based on  notation
e.g., (lambda (x) (* x x)
x is called a bound variable
• Lambda expressions can be applied
e.g., ((lambda (x) (* x x)) 7)
Copyright © 2006 Addison-Wesley. All rights reserved.
1-20
Special Form Function: DEFINE
A Function for Constructing Functions DEFINE - two
forms:
1. To bind a symbol to an expression (a constant)
e.g., (define pi 3.141593)
Example use: (* pi 5 5)
2. To bind names to lambda expressions
e.g., (define (square x) (* x x))
Example use: (square 5)
Names are case-sensitive, include letters, digits and
special characters
Copyright © 2006 Addison-Wesley. All rights reserved.
1-21
Defining values & functions
Type definitions in upper window
Must press Run
(like compiler, not
execution)
System loudly reminds you to press Run!
Copyright © 2006 Addison-Wesley. All rights reserved.
Scheme Run (compile) – an Error
indicates edited
here’s the
syntax error
Copyright © 2006 Addison-Wesley. All rights reserved.
Scheme Run – still an error!
not very
informative

Remember: we call functions (fn-name param). For example,
(square 5). SO, we need a ( in front of square, with a closing )
of course!
Copyright © 2006 Addison-Wesley. All rights reserved.
Scheme – old habits die hard…
No no, the call is (square 5) NOT (square (5))….
Copyright © 2006 Addison-Wesley. All rights reserved.
Scheme – we got it right!
use ctrl-UpArrow to
repeat a command
Copyright © 2006 Addison-Wesley. All rights reserved.
List Functions: CAR and CDR
• CAR takes a list parameter; returns the first element of that list
• FIRST is equivalent to CAR
• CDR takes a list parameter; returns the list after removing its
first element
• REST = CDR
must test for ‘()
before doing car
recursion using cdr
eventually ends up
with ‘()
common errors: 1) treat
an atom like a list or
2) forget quote
Copyright © 2006 Addison-Wesley. All rights reserved.
1-27
Creating Lists
• cons
• append
• list
Copyright © 2006 Addison-Wesley. All rights reserved.
List Functions: CONS
• cons has two forms:
• cons (atom list)
• cons (list list)
• result is a new list that includes the first
parameter as its first element and the
second parameter as the remainder
e.g., (cons 'A '(B C)) returns (A B C)
• Applying CONS to two atoms results in a
dotted list (cell with two atoms, no pointer),
e.g., (cons 'A 'B) returns (A . B)
cons creates node
A
Copyright © 2006 Addison-Wesley. All rights reserved.
B
1-29
Cons Example
(cons atom list)
(cons atom atom)
(cons list list)
Notice (C D) is no longer a list
A
B
C
D
C
A
Copyright © 2006 Addison-Wesley. All rights reserved.
B
D
List Functions: List
• list takes any number of parameters;
returns a list with the parameters as
elements
Repeated for comparison
Copyright © 2006 Addison-Wesley. All rights reserved.
1-31
Example Scheme Function: append
• append has one form:
• append(list list)
• result is a new list containing the elements
of the first parameter followed by the
elements of the second parameter
• Example:
(append '((A B) C) '(D (E F)))
– returns ((A B) C D (E F))
Copyright © 2006 Addison-Wesley. All rights reserved.
1-32
Append Example
Repeated for comparison
Copyright © 2006 Addison-Wesley. All rights reserved.
Scheme Functional Forms
• Composition
–
–
–
–
–
–
–
(cdr (cdr ‘(A B C))) returns ( C )
(car (car '((A B) B C))) returns A
(cdr (car '((A B C) D))) returns (B C)
(cons (car '(A B))(cdr '(A B)))returns(A B)
(caar x) is equivalent to (car (car x))
(cadr x) is equivalent to (car (cdr x))
(caddar x is equivalent to
(car (cdr (cdr (car x))))
Copyright © 2006 Addison-Wesley. All rights reserved.
1-34
Scheme Exercises
• Now you try it. Explore the Scheme
environment. Do exercises 1-3 in the
Scheme Exercises. Review the common
errors.
• Feel free to read more lecture notes and
work ahead. NOTE: In case you need to
comment out some code, comments in
Scheme are indicated by ;
Copyright © 2006 Addison-Wesley. All rights reserved.
Predicate Functions: LIST? and NULL?
• list? takes one parameter; it returns #T if
the parameter is a list; otherwise()
• list? returns #T for the null list ‘()
• null? takes one parameter; it returns #T if
the parameter is the empty list; otherwise()
–
Note that null? returns #T if the parameter is()
Copyright © 2006 Addison-Wesley. All rights reserved.
1-36
Control Flow: IF
• Selection- the special form, IF
(if predicate
true_exp
false_exp)
Example:
(if (<> count 0)
(/ sum count)
0)
Copyright © 2006 Addison-Wesley. All rights reserved.
1-37
Output Functions
• (DISPLAY expression)
• (NEWLINE)
Notice statements
performed in
sequence
Copyright © 2006 Addison-Wesley. All rights reserved.
1-38
If and recursion
empty list is base case
compound else
closes (begin
recursive call
Copyright © 2006 Addison-Wesley. All rights reserved.
call with remainder of list
Control Flow: COND
• Multiple Selection - the special form, COND
General form:
(COND
(predicate_1 expr {expr})
(predicate_2 expr {expr})
...
(predicate_n expr {expr})
(ELSE expr {expr}))
• Returns the value of the last expr in the first pair
whose predicate evaluates to true. Based on
guarded expressions (chapter 9)
• Predicate can be compound (using and, or)
Copyright © 2006 Addison-Wesley. All rights reserved.
1-40
COND example
Notice () around
entire clause
Notice () around
entire clause
close cond,
Could have used
else here
Copyright © 2006 Addison-Wesley. All rights reserved.
close define
Recursion – two ways to build list
Copyright © 2006 Addison-Wesley. All rights reserved.
Numeric Predicate Functions
•
•
•
•
#t (or non-null list) is true
#f or () is false
=, <>, >, <, >=, <=
even?, odd?, zero?, negative?
Copyright © 2006 Addison-Wesley. All rights reserved.
1-43
List Functions: Quote
• QUOTE - takes one parameter;
returns the parameter
without evaluation
• QUOTE is required because
the Scheme interpreter, EVAL,
always evaluates parameters
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
Copyright © 2006 Addison-Wesley. All rights reserved.
1-44
Example Scheme Function: member
• member takes an atom and a simple list;
returns a sublist containing the atom if it is
in the list; #f otherwise
Copyright © 2006 Addison-Wesley. All rights reserved.
1-45
Calling the Scheme eval function
• It is possible to call eval directly
• eval takes a list and evaluates it. The first
item in the list is typically a function.
• (eval '(+ 3 4)) => 7
• (eval '(square 6)) => 36
Copyright © 2006 Addison-Wesley. All rights reserved.
Functions That Build Code
• 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
+ quoted to prevent
evaluation
cons inserts
+ into list
Copyright © 2006 Addison-Wesley. All rights reserved.
1-47
Function to applies a function
• Map – applies (maps) a function
(map list? ‘(a (b c) d) => (#f #t #f)
(define switchView
(lambda (person)
(cond ((equal? person 'i) 'you)
((equal? person 'me) 'you)
((equal? person 'you) 'me)
((equal? person 'your) 'my)
((equal? person 'yours) 'mine)
((equal? person 'am) 'are)
(#t person) )))
(map switchView ‘(i can help you)) => (you can help me)
Copyright © 2006 Addison-Wesley. All rights reserved.
Apply
(apply FN ARG-LIST)
• Returns the result of applying FN to the list
of arguments
• Assume have function:
(define (isVerb word)
(member word '(go have try eat take)))
• Can use with apply:
(apply isVerb ‘(eat)) => ‘(eat take)
(apply isVerb ‘(jump)) => #f
Copyright © 2006 Addison-Wesley. All rights reserved.
Apply Errors
Copyright © 2006 Addison-Wesley. All rights reserved.
Example Scheme Function: LET
• General form:
(let (
(name_1 expression_1)
(name_2 expression_2)
...
(name_n expression_n))
body
)
• Evaluate all expressions, then bind the values to
the names; evaluate the body. Only local.
• Often used to factor out common subexpressions
Copyright © 2006 Addison-Wesley. All rights reserved.
1-51
LET Example
(define (quadratic_roots a b c)
(let (
(root_part_over_2a
(/ (sqrt (- (* b b) (* 4 a c)))(* 2 a)))
(minus_b_over_2a (/ (- 0 b) (* 2 a))))
(begin
(display (+ minus_b_over_2a root_part_over_2a))
(newline)
(display (- minus_b_over_2a root_part_over_2a))
)
)
)
Copyright © 2006 Addison-Wesley. All rights reserved.
1-52
Let*
• Similar to let
• Evaluates the exprs one by one, creating a
location for each id as soon as the value is
available.
(let* ((x 1)
(y (+ x 1)))
(list y x))
=> ‘(2 1)
Copyright © 2006 Addison-Wesley. All rights reserved.
Exercises
• Do Exercises 4-12
• Do converter exercise – to submit,
individual
Copyright © 2006 Addison-Wesley. All rights reserved.
Predicate Function: eq?
• 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 'B) yields #f
– Note that if eq? is called with list parameters,
the result is not reliable we’ll create function in two slides
– Also eq? does not work for numeric atoms,
should use = [appears to work???]
• eqv? works on both symbols and numbers
Copyright © 2006 Addison-Wesley. All rights reserved.
1-55
Our own list_member (for practice)
(define (list_member atm lis)
(cond
((null? lis) #f)
((eq? atm (car lis)) #t)
(else (list_member atm (cdr lis)))
)
)
State recursively:
an element is a member of the list if:
- the element matches the first item in the list
OR
- the element is a member of the rest of the list
How would you modify the above to search sublists?
Copyright © 2006 Addison-Wesley. All rights reserved.
Example Scheme Function: equalsimp
• equalsimp takes two simple lists as parameters; returns #T if
the two simple lists are equal; () otherwise. Won’t handle list
such as ‘(a (b c))
(define (equalsimp lis1 lis2)
(cond
; if lis1 is null, #t is lis2 is null
((null? lis1) (null? lis2))
; if lis2 is null, lis1 is not null, so ‘()
((null? lis2) '())
((eq? (car lis1) (car lis2))
(equalsimp(cdr lis1)(cdr lis2)))
State recursively:
(else '())
two lists are equal if:
))
- the first elements of each list match AND
- the remaining lists (minus first elements) are equal)
Copyright © 2006 Addison-Wesley. All rights reserved.
1-57
Example Scheme Function: equal
• equal takes two general lists as parameters; returns #T if the
two lists are equal; ()otherwise
(define (equal lis1 lis2)
(cond
; if lis1 not a list, checking items in sublist
((not (list? lis1))(eq? lis1 lis2))
; lis1 is a list but lis2 is not
((not (list? lis2)) '())
; rest of code is like equal
((null? lis1) (null? lis2))
((null? lis2) '())
((equal (car lis1) (car lis2))
(equal (cdr lis1) (cdr lis2)))
(else '())
This one can handle ‘(a (b c)) – see trace
))
Copyright © 2006 Addison-Wesley. All rights reserved.
1-58
Equal Example
Copyright © 2006 Addison-Wesley. All rights reserved.
Equal Trace (a (b c)) (a (b c))
lis1: (a (b c)) lis2: (a (b c))
lis1: a lis2: a
lis1 is not a list, checking one item, returning #t
cars are equal, check cdrs
lis1: ((b c)) lis2: ((b c))
lis1: (b c) lis2: (b c)
lis1: b lis2: b
lis1 is not a list, checking one item, returning #t
cars are equal, check cdrs
lis1: (c) lis2: (c)
lis1: c lis2: c
lis1 is not a list, checking one item, returning #t
cars are equal, check cdrs
lis1: () lis2: ()
lis1 is null, return null? lis2 #t
cars are equal, check cdrs
lis1: () lis2: ()
lis1 is null, return null? lis2 #t
Copyright © 2006 Addison-Wesley. All rights reserved.
Equal Trace #2 (a (b c)) (a (d c))
lis1: (a (b c)) lis2: (a (d c))
lis1: a lis2: a
lis1 is not a list, checking one item, returning #t
cars are equal, check cdrs
lis1: ((b c)) lis2: ((d c))
lis1: (b c) lis2: (d c)
lis1: b lis2: d
lis1 is not a list, checking one item, returning #f
#f
Copyright © 2006 Addison-Wesley. All rights reserved.
More Scheme Errors
Copyright © 2006 Addison-Wesley. All rights reserved.
Scheme errors continued
Extra parenthesis, this is the action: (display result) (evenSquareErr2…)
so scheme doesn’t know what to do with:
((display result)(evenSquareErr2…)
Don’t try to use ( .. ) to indicate a block!!
Copyright © 2006 Addison-Wesley. All rights reserved.
Scheme errors continued…
You would expect this to be a syntax error or something! But it
just “falls through” when it hits the else condition.
Copyright © 2006 Addison-Wesley. All rights reserved.
Scheme debugging tip
watch
recursive calls
see which
conditions
matched
Copyright © 2006 Addison-Wesley. All rights reserved.
Scheme Debugging
• Press Debug
current step
Copyright © 2006 Addison-Wesley. All rights reserved.
Scheme Exercises
• Continue with all exercises
Copyright © 2006 Addison-Wesley. All rights reserved.
Closures
From Wikipedia:
• a closure is a function that is evaluated in an
environment containing one or more bound
variables. When called, the function can access these
variables.
• Can also be expressed as: a closure is a function
that captures the lexical environment in which it was
created.
• Constructs such as objects in other languages can
also be modeled with closures (e.g., instance
variables equivalent to bound variables)
Copyright © 2006 Addison-Wesley. All rights reserved.
Closures, continued
• A closure can be used to associate a function with a
set of "private" variables, which persist over several
invocations of the function.
• The scope of the variable encompasses only the
closed-over function, so it cannot be accessed from
other program code. However, the variable is of
indefinite extent, so a value established in one
invocation remains available in the next. similar to static
• The concept of closures was developed in the 60’s
and was first fully implemented as a language
feature in the programming language Scheme. Since
then, many languages have been designed to
support closures.
Copyright © 2006 Addison-Wesley. All rights reserved.
Closures and first-class values
• Closures typically appear in languages in which
functions are first-class values - in other words,
such languages allow functions to be passed as
arguments, returned from function calls, bound to
variable names, etc., just like simpler types such as
strings and integers
;
Copyright © 2006 Addison-Wesley. All rights reserved.
Closure in Scheme
Return a list of all books with at least
; THRESHOLD copies sold.
(define (best-selling-books threshold)
(let ((book-list ‘'(((Gone With the Wind) 1000)
((Freakonomics) 1500) ((Cryptonomicon) 500))))
(filter passed to closure for lambda code & threshold created
(lambda (book)
(>= (book-sales book) threshold))
book-list))
book-list in lexical environment
Copyright © 2006 Addison-Wesley. All rights reserved.
Closure in another language
• ECMAScript – uses function keyword instead of
lambda, creates closure with Array.filter
// Return a list of all books with at least
// THRESHOLD copies sold.
function bestSellingBooks(threshold)
{
filter is higher-order function
- takes a function as a parameter
return bookList.filter( function(book)
{
return book.sales >= threshold;
}
);
}
Copyright © 2006 Addison-Wesley. All rights reserved.
Another closure in JavaScript
Nameless function, inherits environment in which it is
defined. In this case environment includes xhr object and
document object.
xhr.onreadystatechange = function() {
xhr object part of lexical environment
if (xhr.readyState == 4)
{
var result = xhr.responseText;
var place = result.split(‘,’_;
document.getElementById(“city”).value = place[0];
document.getElementById(“state”).value = place[1];
}
}
Copyright © 2006 Addison-Wesley. All rights reserved.
Closures in Ruby
fold_coder = lambda { |default_value, binary_function|
fold_with_acc = lambda { |acc, list|
if list.empty?
acc
else
fold_with_acc.call(binary_function.call(acc,
list.first), list[1..-1])
end
}
lambda { |list|
fold_with_acc.call(default_value, list)
} }
; create closure
adder = fold_coder.call(0, lambda { |a, b| a + b })
; call it
adder.call([1, 2, 3, 4, 5])
adder.call([2, 4, 6, 8, 10])
* From http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html
Copyright © 2006 Addison-Wesley. All rights reserved.
Lexical Closure – from Wiki
"A lexical closure is, first of all, an object- …with
special notation...
• That notation specifies an anonymous piece of code
that can take arguments, and is in fact an
anonymous function. The anonymous function is a
component of the closure object, but not the only
component.
• The other component of the object is the lexical
environment: a snapshot of all of the current
bindings of all of the local variables which are visible
at that point."
• The bindings of the variables are the values of the
variables, not the addresses that the names point to.
Copyright © 2006 Addison-Wesley. All rights reserved.
if addresses, would be just like globals
More Terminology
• Within some scope a free variable is a
variable that is not bound within that
scope, i.e. that within some scope there is
no declaration of that variable.
• The name "Closure" comes from the
terminology that the function-procedure
"closes-over" its environment, capturing
the current bindings of its free variables.
Copyright © 2006 Addison-Wesley. All rights reserved.
Example: Callback with Closures
;; In the library:
(define (register-callback event-type handler-proc)
...)
;; In the application:
(define (make-handler event-type user-data)
(lambda () ...
<code referencing event-type and user-data> ...))
(register-callback event-type
(make-handler event-type ...))
library sees handler-proc as procedure with no arguments
handler procedure has used closure to capture environment – event
type and user data
Copyright © 2006 Addison-Wesley. All rights reserved.
Closure Implementation
• Closures are typically implemented with a special data
structure that contains a pointer to the function code, plus a
representation of the function's lexical environment (e.g., the
set of available variables and their values) at the time when the
closure was created.
• A language implementation cannot easily support full closures
if its run-time memory model allocates all local variables on a
linear stack. In such languages, a function's local variables are
deallocated when the function returns. However, a closure
requires that the free variables it references survive the
enclosing function's execution. Therefore those variables must
be allocated so that they persist until no longer needed. This
explains why typically languages that natively support closures
use garbage collection.
Copyright © 2006 Addison-Wesley. All rights reserved.
Closure Implementation (continued)
• A typical modern Scheme implementation
allocates local variables that might be used
by closures dynamically and stores all other
local variables on the stack.
Copyright © 2006 Addison-Wesley. All rights reserved.
Interesting Perspectives
• http://home.tiac.net/~cri/2005/closure.html
• http://gafter.blogspot.com/2007/01/definitionof-closures.html
Copyright © 2006 Addison-Wesley. All rights reserved.
Applications of Functional Languages
• APL is used for throw-away programs
• LISP is used for artificial intelligence
–
–
–
–
–
Knowledge representation/Expert systems
Machine learning
Natural language processing
Modeling of speech and vision
Emacs editor
• Scheme is used to teach introductory
programming at a significant number of
universities
• Haskell and ML in research labs
Copyright © 2006 Addison-Wesley. All rights reserved.
1-81
Comparing Functional and Imperative
Languages
• Imperative Languages:
–
–
–
–
Efficient execution
Complex semantics
Complex syntax
Concurrency is programmer designed
• Functional Languages:
– Simple semantics (like math functions, may or
may not feel “natural” to programmers)
– Simple syntax
– Inefficient execution (not as bad if compiled)
– Programs can automatically be made concurrent
Copyright © 2006 Addison-Wesley. All rights reserved.
1-82
Summary
• Functional programming languages use function application,
conditional expressions, recursion, and functional forms to
control program execution instead of imperative features
such as variables and assignments
• LISP began as a purely functional language and later included
imperative features
• Scheme is a relatively simple dialect of LISP that uses static
scoping exclusively
• COMMON LISP is a large LISP-based language
• ML is a static-scoped and strongly typed functional language
which includes type inference, exception handling, and a
variety of data structures and abstract data types
• Haskell is a lazy functional language supporting infinite lists
and set comprehension.
• Purely functional languages have advantages over imperative
alternatives, but their lower efficiency on existing machine
architectures has prevented them from enjoying widespread
use
Copyright © 2006 Addison-Wesley. All rights reserved.
1-83