15 functional programming

ICS 313 - Fundamentals of Programming Languages 1
15. Functional Programming
15.1 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

15.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
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)(3)
which evaluates to 27
15.2 Mathematical Functions (continued)
Functional Forms
A higher-order function, or functional form, is one
that either takes functions as parameters or yields a
function as its result, or both
Function Composition
A functional form that takes two functions as parameters
and yields a function whose result is a function whose
value is the first actual parameter function applied to the
result of the application of the second
Form: h ≡ f ° g
which means h (x) ≡ f ( g ( x))

15.2 Mathematical Functions (continued)
Construction
A functional form that takes a list of functions as parameters and yields
a list of the results of applying each of its parameter functions to a
given parameter
Form: [f, g]
For f (x) ≡ x * x * x and g (x) ≡ x + 3,
[f, g] (4) yields (64, 7)
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 * x
α ( h, (3, 2, 4)) yields (27, 8, 64)
15.3 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
In an FPL, the evaluation of a function always produces the
same result given the same parameters
This is called referential transparency

Functional Programming Languages
LISP
Lambda notation is used to specify functions and function definitions, function
applications, and data all have the same form
Scheme
A mid-1970s dialect of LISP, designed to be a cleaner, more modern, and simpler
version than the contemporary dialects of LISP
COMMON LISP
A combination of many of the features of the popular dialects of LISP around in the
early 1980s
ML
A static-scoped functional language with syntax that is closer to Pascal than to LISP
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)
15.8 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
Examples
Fibonacci numbers (illustrates function definitions with different
parameter forms)
fib 0 = 1
fib 1 = 1
fib (n + 2) = fib (n + 1) + fib n

15.8 Haskell (continued)
Factorial (illustrates guards)
fact n
| n == 0 = 1
| n > 0 = n * fact (n - 1)
The special word otherwise can appear as a guard
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]
Catenation is with ++
e.g., [1, 3] ++ [5, 7] results in [1, 3, 5, 7]
CAR and CDR via the colon operator (as in Prolog)
e.g., 1:[3, 5, 7] results in [1, 3, 5, 7]
Examples:
product [] = 1
product (a:x) = a * product x
fact n = product [1..n]
List comprehensions: set notation
e.g.,
[n * n | n ← [1..20]]
defines a list of the squares of the first 20 positive integers
factors n = [i | i [1..n div 2],n mod i == 0]
This function computes all of the factors of its given parameter
Quicksort:
sort [] = []
sort (a:x) = sort [b | b ← x; b <= a]
++ [a] ++
sort [b | b ← x; b > a]

Lazy evaluation
Infinite lists
e.g.,
positives = [0..]
squares = [n * n | n ← [0..]]
(only compute those that are necessary)
e.g.,
member squares 16
would return True
The member function could be written as:
member [] b = False
member (a:x) b = (a == b) || member x b
However, this would only work if the parameter to squares was
a perfect square; if not, it will keep generating them forever.
The following version will always work:
member2 (m:x) n
| m < n = member2 x n
| m == n = True
| otherwise = False
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
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

15 functional programming

More Related Content

What's hot (20)

Viewers also liked (11)

Similar to 15 functional programming (20)

More from jigeno (10)

Recently uploaded (20)

15 functional programming