Chapter 15

Functional Programming Languages

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
1-2

Mathematical Functions
A mathematical function is a mapping of members of one set, called the domain set, to another set, called the range set 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

1-3

Lambda Expressions
Lambda expressions describe nameless functions 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

1-4

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)) For f (x) x + 2 and g (x) 3 * x, h f g yields (3 * x)+ 2

1-5

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)

1-6

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 Referential Transparency - In an FPL, the evaluation of a function always produces the same result given the same parameters
1-7

LISP Data Types and Structures

Data object types: originally only atoms and lists List form: parenthesized collections of sublists and/or atoms e.g., (A B (C D) E) Originally, LISP was a typeless language LISP lists are stored internally as singlelinked lists

1-8

LISP Interpretation
Lambda notation is used to specify functions and function definitions. Function applications and data have the same form. e.g., 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 The first LISP interpreter appeared only as a demonstration of the universality of the computational capabilities of the notation
1-10

The Scheme Interpreter

In interactive mode, the Scheme interpreter is an infinite read-evaluate-print loop (REPL)
This form of interpreter is also used by Python and Ruby

Expressions are interpreted by the function

EVAL

Literals evaluate to themselves

1-11

Primitive Functions &

LAMBDA

Expressions

Primitive Arithmetic Functions: +, -, *, /, ABS, SQRT, REMAINDER, MIN, MAX e.g., (+ 5 2) yields 7

Lambda Expressions Form is based on notation e.g., (LAMBDA (x) (* x x) x is called a bound variable Lambda expressions can be applied to parameters e.g., ((LAMBDA (x) (* x x)) 7) yields 49 x:bound variable LAMBDA expressions can have any number of parameters (LAMBDA (a b x) (+ (* a x x) (* b x)))
1-12

Special Form Function: DEFINE

DEFINE - Two forms:
1. To bind a symbol to an expression e.g., (DEFINE pi 3.141593) Example use: (DEFINE two_pi (* 2 pi))
These symbols are not variables they are like the names bound by Javas final declarations

2. To bind names to lambda expressions (LAMBDA is implicit) e.g., (DEFINE (square x) (* x x)) Example use: (square 5)displays 25 - The evaluation process for DEFINE is different! The first parameter is never evaluated. The second parameter is evaluated and bound to the first parameter.
1-13

Output Functions
Usually not needed, because the interpreter always displays the result of a function evaluated at the top level (not nested) Scheme has PRINTF, which is similar to the printf function of C Note: explicit input and output are not part of the pure functional programming model, because input operations change the state of the program and output operations are side effects
1-14

Output Functions
(DISPLAY expression) (NEWLINE)

1-15

Numeric Predicate Functions

#T

(or #t) is true and #F (or #f) is false (sometimes () is used for false) =, <>, >, <, >=, <= EVEN?, ODD?, ZERO?, NEGATIVE?

The NOT function inverts the logic of a Boolean expression

1-16

Control Flow
Selection- the special form, IF (IF predicate then_exp else_exp)
(IF (<> count 0) (/ sum count) )

Recall from Chapter 8 the

COND

function:

(DEFINE (leap? year) (COND ((ZERO? (MODULO year 400)) #T) ((ZERO? (MODULO year 100)) #F) (ELSE (ZERO? (MODULO year 4))) ))
1-17

Control Flow: COND

Multiple Selection - the special form, COND General form: (COND (predicate_1 expr {expr}) (predicate_1 expr {expr}) ... (predicate_1 expr {expr}) (ELSE expr {expr})) Returns the value of the last expression in the first pair whose predicate evaluates to true
1-18

Example of COND
(DEFINE (compare x y) (COND ((> x y) x is greater than y) ((< x y) y is greater than x) (ELSE x and y are equal) ) )

1-19

List Functions: CONS and LIST

CONS takes two parameters, the first of which can be either an atom or a list and the second of which is a list; returns a new list that includes the first parameter as its first element and the second parameter as the remainder of its result e.g., (CONS 'A '(B C)) returns (A B C)

1-20

List Functions
QUOTE

parameter without evaluation

- takes one parameter; returns the

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 '(A B) is equivalent to (QUOTE (A B))

(QUOTE A)- returns A (QUOTE (A B C)) returns (A B C)

1-22

List Functions: CAR and CDR

CAR takes a list parameter; returns the first element of that list e.g., (CAR '(A B C)) yields A (CAR '((A B) C D)) yields (A B) CDR takes a list parameter; returns the list after removing its first element e.g., (CDR '(A B C)) yields (B C) (CDR '((A B) C D)) yields (C D)

1-23

List Functions
Examples:

(continued)

(CAR ((A B) C D)) returns (A B) (CAR A) is an error (CDR ((A B) C D)) returns (C D) (CDR A) is an error (CDR (A)) returns () (CONS () (A B)) returns (() A B) (CONS (A B) (C D)) returns ((A B) C D)

(CONS A B) returns (A . B)

(a dotted pair)

1-24

List Functions

(continued)

LIST is a function for building a list from

any number of parameters

(apple orange grape)

(LIST apple orange grape) returns

1-25

List Functions: CONS and LIST

LIST takes any number of parameters; returns a list with the parameters as elements

1-26

Predicate Function:
EQ?

EQ?

takes two expressions as parameters (usually two atoms); it returns #T if both parameters have the same pointer value; otherwise #F
(EQ? 'A 'A) yields #T

(EQ? 'A 'B) yields #F (EQ? 'A '(A B)) yields #F (EQ? '(A B) '(A B)) yields #T or #F (EQ? 3.4 (+ 3 0.4))) yields #T or #F

1-27

Predicate Function:
EQV?

EQV?

is like EQ?, except that it works for both symbolic and numeric atoms; it is a value comparison, not a pointer comparison

(EQV? 3 3) yields #T

(EQV? 'A 3) yields #F (EQV 3.4 (+ 3 0.4)) yields #T

(EQV? 3.0 3) yields #F

different)

(floats and integers are

1-28

Predicate Functions: LIST? and NULL?

LIST?

takes one parameter; it returns parameter is a list; otherwise #F

(LIST? '()) yields #T

#T

if the

NULL?

takes one parameter; it returns #T if the parameter is the empty list; otherwise #F
(NULL? '(())) yields #F

1-29

Example Scheme Function: member

member takes an atom and a simple list; returns #T if the atom is in the list; #F

otherwise

DEFINE (member atm a_list) (COND ((NULL? a_list) #F) ((EQ? atm (CAR lis)) #T) ((ELSE (member atm (CDR a_list))) ))

1-30

Example Scheme Function: equalsimp

equalsimp takes two simple lists as parameters; returns #T if the two simple lists are equal; #F otherwise (DEFINE (equalsimp list1 list2) (COND ((NULL? list1) (NULL? list2)) ((NULL? list2) #F) ((EQ? (CAR list1) (CAR list2)) (equalsimp(CDR list1)(CDR list2))) (ELSE #F) ))

1-31

Example Scheme Function: equal

equal takes two general lists as parameters; returns #T if the two lists are equal; #F otherwise (DEFINE (equal list1 list2) (COND ((NOT (LIST? list1))(EQ? list1 list2)) ((NOT (LIST? lis2)) #F) ((NULL? list1) (NULL? list2)) ((NULL? list2) #F) ((equal (CAR list1) (CAR list2)) (equal (CDR list1) (CDR list2))) (ELSE #F) ))
1-32

Example Scheme Function: append

append takes two lists as parameters; returns the first parameter list with the elements of the second parameter list appended at the end (DEFINE (append list1 list2) (COND ((NULL? list1) list2) (ELSE (CONS (CAR list1) (append (CDR list1) list2))) ))

1-33

Comparing Functional and Imperative Languages

Imperative Languages:

Efficient execution Complex semantics Complex syntax Concurrency is programmer designed

Simple semantics Simple syntax Less efficient execution Programs can automatically be made concurrent

Functional Languages:

1-34

Summary
Functional programming languages use function application, conditional expressions, recursion, and functional forms to control program execution 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 that uses type inference Haskell is a lazy functional language supporting infinite lists and set comprehension. F# is a .NET functional language that also supports imperative and object-oriented programming Some primarily imperative languages now incorporate some support for functional programming Purely functional languages have advantages over imperative alternatives, but still are not very widely used
1-35