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 structure CELL A List “(a b c)” a bc

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 Example Pg 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, ]] –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 | ….

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 C – control string (e.g. program) D – dump, the previous state for function return

Data types Expr – –ID(identifier) –Lambda(identifier, expr) –Application(expr 1, expr 2 ) (apply symbol) WHNF – –INT(number) –Primary(WHNF -> WHNF) –Closure(expr, identifier, list( (identifier, WHNF)))

Data types (cont.) Stack – list (WHNF) Environment – list ( ) Control – list ( expr) Dump – list ( ) State – –

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(nil, (id,arg)::E1, expr, (S,E,C)::D)

Evaluate Function (cont.) -> Evaluate(f(arg)::S,E,C,D) Evaluate(S,E,Application(fun,arg)::C,D) ->

Functional Programming Little used in commercial circles Used in some research circle May hold the future for parallel computation