Presentation is loading. Please wait.

Presentation is loading. Please wait.

Functional Languages. Why? Referential Transparency Functions as first class objects Higher level of abstraction Potential for parallel execution.

Similar presentations


Presentation on theme: "Functional Languages. Why? Referential Transparency Functions as first class objects Higher level of abstraction Potential for parallel execution."— Presentation transcript:

1 Functional Languages

2 Why? Referential Transparency Functions as first class objects Higher level of abstraction Potential for parallel execution

3 History LISP is one of the oldest languages (‘56- ’59)! AI & John McCarthy Roots: –Church’s Lambda Calculus (Entscheidungsproblem!) –Church’s students

4 Functional Languages LISP and its family –LISP, Common LISP, Scheme Haskell Miranda ML FP (John Backus)

5 Recent Events Paul Graham – Hackers and Painters

6 Lambda Calculus Abstract definition of functions x.x*x Application: ( x.x*x)5 Multiple arguments x.( y.x*y)

7 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

8 Evaluation (cont.) Beta Reduction – ( x.x+y)(z+w) –( x.x+y)[x/(z+w)] –(z+w)+y

9 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

10 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))))))

11 Combinatory Calculus I = x.x K = x. y.x S = x. y. z.xz(yz)

12 Church-Rosser Theorem Order of application and reduction does not matter!

13 LISP Syntax – parenthesis! Functions are written in prefix list form: –(add 4 5)

14 LISP data structure CELL A List “(a b c)” a bc

15 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

16 List Functions List Accessors car: (car ‘(a b c)) -> a cdr (cdr ‘(a b c)) -> (b c)

17 List Functions List constructors list (list ‘a ‘b) -> (a b) cons (cons ‘a ‘b) -> (a.b) What is happening here?

18 Symbolic Differentiation Example Pg 226

19 Haskell Better syntax! Named for Haskell Curry – a logician 1999

20 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]

21 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]

22 Control Flow If The Else statements Functions: name :: Domain -> Range name | ….

23 Example Function max3 :: Int -> Int -> Int -> Int Max3 x y z | x >=y && x >= z = x | y >= x && y >= z = y | otherwise = z

24 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]

25 Implementation Lazy evaluation Eager evaluation Graph reduction

26 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

27 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)))

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

29 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)

30 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)

31 Evaluate Function (cont.) Evaluate(Closure(expr,id,E1)::(arg::S),E, @::C,D) -> Evaluate(nil, (id,arg)::E1, expr, (S,E,C)::D)

32 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)

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


Download ppt "Functional Languages. Why? Referential Transparency Functions as first class objects Higher level of abstraction Potential for parallel execution."

Similar presentations


Ads by Google