1 / 33

The Evolution of Functional Languages

Explore the history, concepts, and recent events in functional programming languages like LISP, Haskell, and ML. From referential transparency to lambda calculus, delve into higher levels of abstraction and the potential for parallel execution.

opa
Download Presentation

The Evolution of Functional Languages

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

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 lx.x*x Application: (lx.x*x)5 Multiple arguments lx.(ly.x*y)

  7. 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

  8. Evaluation (cont.) • Beta Reduction • (lx.x+y)(z+w) • (lx.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 = 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))))))

  11. Combinatory Calculus • I = lx.x • K = lx.ly.x • S = lx.ly.lz.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)” b c a

  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 ExamplePg 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 <vars> | <s1> | <s2> ….

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

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

  28. Data types (cont.) • Stack – list (WHNF) • Environment – list ( <identifier, WHNF>) • Control – list ( expr) • Dump – list (<Stack, Environment, Control>) • State – • <Stack, Environment, Control, Dump>

  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

More Related