330 likes | 428 Views
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!)
E N D
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 lx.x*x Application: (lx.x*x)5 Multiple arguments lx.(ly.x*y)
Evaluation • Bound Variables • lx.(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 • (lx.x+y)(z+w) • (lx.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 = lf.lx.(x) • 1 = lf.lx.(fx) • 2 = lf.lx.(f(fx)) • Succ = ln. (lf.(lx.(f(n f) x))) • Add = lm. (ln. (lf.(lx.((mf)((nf)x))))))
Combinatory Calculus • I = lx.x • K = lx.ly.x • S = lx.ly.lz.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)” b c a
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?
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