Functional Programing

Referencing material fromProgramming Language Pragmatics – Third Edition – by Michael L.

ScottAndy Balaam (Youtube.com/user/ajbalaam)

Historical OriginsHow did we get here

History

• From the work of Alan Turing, Alonzo Church, Stephen Kleene, Emil Post, and others• Each worked on their own• Each made a formalized notion of an algorithm• Church’s Thesis:Any intuitively appealing model of computing would be equally powerfull

Two ParadigmsTuring Machine(Imperative Languages)

• Based on pushdown automaton• A pushdown automata uses a stack• Uses an unbounded storage “tape”• Computation is done by reading and writing

values from cells on the tape

• Example: Google Doodle for Alan Turing’s 100th Birthday

• All of the languages you have learned in 201 and 202

Lambda Calculus(Functional Languages)

• Based on parameterized expressions, each parameter is introduced with a

• One substitutes parameters into expression to compute each expression

• Example: Scheme (later)• Lisp (scheme, rocket), Haskell, Miranda,

pH, Sisal, Single Assignment C, Erlang

Functional Programming ConceptsA completely new paradigm

No side effects

• Based on function• A function takes parameters and returns something• Functions can not modify values

First Class values

• Everything is a first class value, including functions• This allows for higher order functions, which operate on

functions.

Polymorphism

• Most functional languages are polymorphic• Lisp (Scheme, Rocket, etc.) is dynamically typed• Functions can take many different types and conditionally deal with

them based on type

Lists

• A list is an item followed by a list• This leads to natural recursion• Provides the only way to repeatedly do something

• Operate on the first element, do the same with the rest (hint: recursion)

SchemeA language with only one feature

Scheme is a dialect of Lisp

• Lisp stands for LISt Processing• It is usually interpreted, although can be compiled• Scheme uses prefix (Caimbrige Polish Notation) – although

this makes sense

Scheme Interpreters

• Dr. Scheme – deprecated• Rocket – for the Rocket dialect

• MIT Scheme – its own implementation

My Chosen best:SISC - Second Interpreter of Scheme Code• In java – portable• Uses standard Scheme in a simple command-line environment

You can do one thing

(item item item item item item item)

A Scheme program

(operation operation operation operation)Operation: (operator operand operand operand)

How to do things

• Addition, subtraction, multiplication, and division are predefined and referred to with +,-,*,/.• Other operations, like modulus are referred to with words• In order to trigger evaluation you must wrap an operation in parenthasys

• (+ 1 2) evaluates to 3• 7 is already evaluated, it results in 7• (7) tries to run the function 7. 7 is not a function• Similarly ((+ 1 2)) tries to run the function 3

How to not do things

• A single quote defines a list• Because an operation is a list, this means that we can use the

single quote to do operations on a operation or return the operation

‘(+ 1 2) results in the list (+ 1 2)

Booleans

• #t for true• #f for false

Control flow

IfIf [Boolean] [expr if true] [expr if false]

CondCond

([boolean] [expr])([boolean] [expr])(else [expr if else])

Dynamic typing

(if (> a 0) (+ 2 3) (+ 2 “foo”))

This will execute fine? Why?

Defining items – lambda expressions

• From lambda calculus• Lambda takes two arguments, a list of identifiers, and an

expression to compute using them• Lambda (x) (* x x) is a function that takes a value and returns

its square

Defining – function ‘Define’As the Book does it

• Define takes two parameters, an identifier, and a function• (Define pow (lambda (x) (* x x)) allows us to use the function

pow that takes a parameter and returns its square

Defining – function ‘Define’Another way

• Define takes two parameters, a list matching how it should be called, and an expression using the identifiers given in the first part• This merges lambda expressions and definition• (define (pow x) (* x x)) defines the same thing as before

Defining – local bindings

• Defining is just global binding• You can create local bindings using let• Let takes a list of defines parameters and an expression, and

runs the expression using that set of defines

Lists

• Everything is a list• Recall: a single quote makes a set of parenthesis not evaluate and

stay as a list• ‘(1 2 3) is a list• Recall: a list is an item followed by a list• What about the last item?• Null? [list]

List operations

• Car [list]• Cdr [list]• Cons [item] [list]

Higher-Order FunctionsI heard you like functions, so we made your functions return

functions, so you can compute what you compute.

Metaprogramming is just programming

• Metaprogramming is writing code about code• Lisp doesn’t care

• Lisp is homoiconic – a lisp program is a list.• A function can be an argument to a function, or it can be

returned from a function

Common Higher order functions

• Define• Load• Lambda• For-each• Call• apply• compose

Example – Folding

(define fold (lambda (f I l)(if (null? L) I

(f (car l) (fold f I (cdr l))))))

This takes a function f to fold the list l using the identity i

Evaluation OrderPutting functional programming in order

Evaluation orderApplicative-order

• You evaluate each argument before you pass it to a function

Normal-order• You pass each argument as an

unevaluated expression

Example (Right from the book)

Applicative-order(double (* 3 4))(double 12)(+ 12 12)24

What kind of cases could applicative order be wasteful?

Normal-order(double (* 3 4))(+ (* 3 4) (* 3 4))(+ 12 (* 3 4))(+ 12 12)24This is much longerWe calculate the same value twice

(Define double (lambda (x) (+ x x)))(double (* 3 4))

Scheme

The book claims that scheme evaluates in applicative-order.

But what about this line? (We just saw this in dynamic typing)(if (> a 0) (+ 2 3) (+ 2 “foo”))

In reality: Lazy evaluation

• We evaluate any evaluable expressions and store their value for later use• We can forget about this, it is behind the scenes

Functional Programming in Perspective

Functional and comparative, when and why

Side-effect free

• Its simple• Not much advanced computer science

needed• Perfect for math• No required evaluation order (other

than common sense)• Parallelism doesn’t matter (the only

way to “talk” is to pass variables)

• Some general programming ideas require assignment (we can’t do that)

• I/O is difficult (technically impossible without side effects)

• Any small update requires an entire new copy of the data

In conclusion

• Fun• Easy to use• You can make a computational program easily

• Not a tool for every job, but every tool has a job.