Functional Languages

Why?

• Referential Transparency

• Functions as first class objects

• Higher level of abstraction

• Potential for parallel execution

History

• LISP is one of the oldest languages (‘56-’59)!

• AI & John McCarthy

• Roots:– Church’s Lambda Calculus

(Entscheidungsproblem!)– Church’s students

Functional Languages

• LISP and its family– LISP, Common LISP, Scheme

• Haskell

• Miranda

• ML

• FP (John Backus)

Recent Events

• Paul Graham – Hackers and Painters

Lambda Calculus

• Abstract definition of functions

x.x*x

Application:

(x.x*x)5

Multiple arguments

x.(y.x*y)

Evaluation

• Bound Variables• x.(x+y)

• Substitution– M[x/N] – sub N in for x in expression M– Valid when free variables in N are not bound in

M– Variables can be renamed

Evaluation (cont.)

• Beta Reduction– (x.x+y)(z+w)– (x.x+y)[x/(z+w)]– (z+w)+y

Two sides of the Lambda Calculus

• The programming language side is what we have seen

• Also – used for type systems

• The theory side used to proof the Entscheidungsproblem

Defining Numbers

• 0 = f.x.(x)

• 1 = f.x.(fx)

• 2 = f.x.(f(fx))

• Succ = n. (f.(x.(f(n f) x)))

• Add = m. (n. (f.(x.((mf)((nf)x))))))

Combinatory Calculus

• I = x.x

• K = x.y.x

• S = x.y.z.xz(yz)

Church-Rosser Theorem

• Order of application and reduction does not matter!

LISP

• Syntax – parenthesis!

• Functions are written in prefix list form:– (add 4 5)

LISP data structureCELL

A List “(a b c)”

a b c

Evaluation

• LISP assumes a list is a function unless evaluation is stopped!

• (a b c) - apply function a to arguments b and c

• Quote: ‘(a b c) – a list not to be evaluated

List Functions

List Accessors

car: (car ‘(a b c)) -> a

cdr (cdr ‘(a b c)) -> (b c)

List Functions

List constructors

list (list ‘a ‘b) -> (a b)

cons (cons ‘a ‘b) -> (a.b)

What is happening here?

Symbolic Differentiation ExamplePg 226

Haskell

• Better syntax!

• Named for Haskell Curry – a logician

• 1999

Expressions

• Use normal infix notation

• Lists as a fundamental data type (most functional languages provide this)– Enumeration -> evens=[0, 2, 4, 6]– Generation ->

• Moreevens = [ 2*x | x <- [0,1 .. 101]]

– Construction• 8:[] – [8]

Expressions (cont.)

• List accessors – head and tail– head evens – 0– tail evens – [2,4,6]

• List concatenation– [1, 2] ++ [3, 4] – [1, 2, 3, 4]

Control Flow

• If The Else statements

• Functions:name :: Domain -> Range

name <vars>| <s1>

| <s2>

….

Example Function

max3 :: Int -> Int -> Int -> Int

Max3 x y z

| x >=y && x >= z = x

| y >= x && y >= z = y

| otherwise = z

Recursion and Iteration

• Recursion follows the obvious pattern

• Iteration uses lists:– Fact n = product [1 .. N]

• Another pattern for recursion on lists– mySum [] = 0– mySum [x : xs] = x + mySum[xs]

Implementation

• Lazy evaluation

• Eager evaluation

• Graph reduction

SECD Machine

• Four Data Structures (lists)

• S – stack, expression evaluation

• E – environment list of <id, value>

• C – control string (e.g. program)

• D – dump, the previous state for function return

Data types

• Expr – – ID(identifier)

– Lambda(identifier, expr)

– Application(expr1, expr2)

– @ (apply symbol)

• WHNF –– INT(number)

– Primary(WHNF -> WHNF)

– Closure(expr, identifier, list( (identifier, WHNF)))

Data types (cont.)

• Stack – list (WHNF)

• Environment – list ( <identifier, WHNF>)

• Control – list ( expr)

• Dump – list (<Stack, Environment, Control>)

• State – – <Stack, Environment, Control, Dump>

Evaluate Function

• Evaluate maps State -> WHNF

• Cases for Control List empty:

• Evaluate(Result::S,E,nil,nil) -> Result

• Evaluate(x::S,E,nil,(S1,E1,C1)) -> Evaluate(x::S1,E1,C1,D)

Evaluate Function (cont.)

• Evaluate(S,E,ID(x)::C,D) ->

Evaluate(LookUp(x,E)::S,E,C,D)

• Evaluate(S,E,LAMBDA(id,expr),D) -> Evaluate(

Closure(expr,id,E1)::S,

E,C,D)

Evaluate Function (cont.)

• Evaluate(Closure(expr,id,E1)::(arg::S),E, @::C,D) ->

Evaluate(nil,

(id,arg)::E1,

expr,

(S,E,C)::D)

Evaluate Function (cont.)

• Evaluate(Primary(f)::(arg::S),E,@::C,D) -> Evaluate(f(arg)::S,E,C,D)

• Evaluate(S,E,Application(fun,arg)::C,D) -> Evaluate(S,E,arg::(fun::(@::C)),D)

Functional Programming

• Little used in commercial circles

• Used in some research circle

• May hold the future for parallel computation