Upload
opa
View
34
Download
0
Embed Size (px)
DESCRIPTION
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!) - PowerPoint PPT Presentation
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