Upload
edmund-logan
View
221
Download
0
Embed Size (px)
Citation preview
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