Programming Languages Foundation & Innovations

1. CS5205: Foundation in Programming LanguagesLecture 1 :Overview “Language Foundation, Extensions and Reasoning Lecturer : Chin Wei Ngan Email : chinwn@comp.nus.edu.sg Office : S15 06-01 Introduction

2. Course Objectives - graduate-level course with foundation focus - languages as tool for programming - foundations for reasoning about programs - explore various language innovations Introduction

3. Course Outline • Lecture Topics (13 weeks) • Lambda Calculus • Advanced Language (Haskell) • http://www.haskell.org • Type System for Lightweight Analysis • http://www.cs.cmu.edu/~rwh/plbook/book.pdf • Semantics • Formal Reasoning – Separation Logic + Provers • Language Innovations (paper readings) Introduction

4. Administrative Matters - mainly IVLE - Reading Materials (mostly online): www.haskell.org Robert Harper : Foundations of Practical Programming Languages. Free PL books : http://www.cs.uu.nl/~franka/ref - Lectures + Assignments + Presentation + Exam - Assignment/Quiz (30%) - Paper Reading + Critique (25%) - Exam (45%) Introduction

5. Paper Critique • Focus on Language Innovations • Select Topic (Week 3) • 2-Page Summary (Week 5) • Prepare Presentation (Week 7) • Oral Presentation (Last 4 weeks) • Paper Critique (Week 13) • Possible Topics • Concurrent and MultiCore Programming • Software Transaction Memory • GUI Programming with Array • Testing with QuickCheck • IDE for Haskell • SELinks (OCaml) Introduction

6. Advanced Language - Haskell • Strongly-typed with polymorphism • Higher-order functions • Pure Lazy Language. • Algebraic data types + records • Exceptions • Type classes, Monads, Arrows, etc • Advantages : concise, abstract, reuse • Why use Haskell ? cool & greater productivity Introduction

7. type is : (a  b)  (List a) (List b) Example - Haskell Program • Apply a function to every element of a list. • data List a = Nil | Cons a (List a) • map f Nil = Nil • map f (Cons x xs) = Cons (f x) (map f xs) • map inc (Cons 1 (Cons 2 (Cons 3 Nil))) • ==> (Cons 2 (Cons 3 (Cons 4 Nil))) a type variable Introduction

8. Some Applications • Hoogle – search in code library • Darcs – distributed version control • Programming user interface with arrows.. • How to program multicore? • map/reduce and Cloud computing • Some issues to be studied in Paper Reading. Introduction

9. detect bugs Type System – Lightweight Analysis • Abstract description of code + genericity • Compile-time analysis that is tractable • Guarantees absence of some bad behaviors • Issues – expressivity, soundness, • completeness, inference? • How to use, design and prove type system. • Why? Introduction

10. sw reliability Specification with Separation Logic • Is sorting algorithm correct? • Any memory leaks? • Any null pointer dereference? • Any array bound violation? • What is the your specification/contract? • How to verify program correctness? • Issues – mutation and aliasing • Why? Introduction

11. Lambda Calculus • Untyped Lambda Calculus • Evaluation Strategy • Techniques - encoding, extensions, recursion • Operational Semantics • Explicit Typing Introduction to Lambda Calculus: http://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf http://www.cs.chalmers.se/Cs/Research/Logic/TypesSS05/Extra/geuvers.pdf Lambda Calculator : http://ozark.hendrix.edu/~burch/proj/lambda/download.html Introduction

12. Untyped Lambda Calculus • Extremely simple programming language which captures core aspects of computation and yet allows programs to be treated as mathematical objects. • Focused on functions and applications. • Invented by Alonzo (1936,1941), used in programming (Lisp) by John McCarthy (1959). Introduction

13. Functions without Names Usually functions are given a name (e.g. in language C): int plusOne(int x) { return x+1; } …plusOne(5)… However, function names can also be dropped: (int (int x) { return x+1;} ) (5) Notation used in untyped lambda calculus: (l x . x+1) (5) Introduction

14. Syntax • In purest form (no constraints, no built-in operations), the lambda calculus has the following syntax. • t ::= terms • x variable • l x . t abstraction • t t application This is simplest universal programming language! Introduction

15. Conventions • Parentheses are used to avoid ambiguities. • e.g. x y z can be either (x y) z or x (y z) • Two conventions for avoiding too many parentheses: • Applications associates to the left • e.g. x y z stands for (x y) z • Bodies of lambdas extend as far as possible. • e.g. l x. l y. x y x stands for l x. (l y. ((x y) x)). • Nested lambdas may be collapsed together. • e.g. l x. l y. x y x can be written as l x y. x y x Introduction

16. Scope • An occurrence of variable x is said to be bound when it occurs in the body t of an abstraction l x . t • An occurrence of x is free if it appears in a position where it is not bound by an enclosing abstraction of x. • Examples: x y • y. x y l x. x (identity function) • (l x. x x) (l x. x x) (non-stop loop) • (l x. x) y • (l x. x) x Introduction

17. Alpha Renaming • Lambda expressions are equivalent up to bound variable renaming. • e.g. l x. x =a l y. y • l y. x y =a l z. x z • But NOT: • l y. x y =a l y. z y • Alpha renaming rule: • l x . E =a l z . [x a z] E (z is not free in E) Introduction

18. Beta Reduction • An application whose LHS is an abstraction, evaluates to the body of the abstraction with parameter substitution. • e.g. (l x. x y) z !b z y • (l x. y) z!b y • (l x. x x) (l x. x x)!b (l x. x x) (l x. x x) • Beta reduction rule (operational semantics): • ( l x . t1 ) t2!b [x a t2] t1 • Expression of form ( l x . t1 ) t2is called a redex (reducible expression). Introduction

19. Evaluation Strategies • A term may have many redexes. Evaluation strategies can be used to limit the number of ways in which a term can be reduced. • An evaluation strategy is deterministic, if it allows reduction with at most one redex, for any term. • Examples: • - full beta reduction • - normal order • - call by name • - call by value, etc Introduction

20. Full Beta Reduction • Any redex can be chosen, and evaluation proceeds until no more redexes found. • Example: (lx.x) ((lx.x) (lz. (lx.x) z)) • denoted by id (id (lz. id z)) • Three possible redexes to choose: • id (id (lz. id z)) • id (id (lz. id z)) • id (id (lz. id z)) • Reduction: • id (id (lz. id z)) • ! id (id (lz.z)) • !id (lz.z) • !lz.z • ! Introduction

21. Normal Order Reduction • Deterministic strategy which chooses the leftmost, outermost redex, until no more redexes. • Example Reduction: • id (id (lz. id z)) • !id (lz. id z)) • !lz.id z • !lz.z • ! Introduction

22. Call by Name Reduction • Chooses the leftmost, outermost redex, but never reduces inside abstractions. • Example: • id (id (lz. id z)) • !id (lz. id z)) • !lz.id z • ! Introduction

23. Call by Value Reduction • Chooses the leftmost, innermost redex whose RHS is a value; and never reduces inside abstractions. • Example: • id (id (lz. id z)) • ! id (lz. id z) • !lz.id z • ! Introduction

24. Strict vs Non-Strict Languages • Strict languages always evaluate all arguments to function before entering call. They employ call-by-value evaluation (e.g. C, Java, ML). • Non-strict languages will enter function call and only evaluate the arguments as they are required. Call-by-name (e.g. Algol-60) and call-by-need (e.g. Haskell) are possible evaluation strategies, with the latter avoiding the re-evaluation of arguments. • In the case of call-by-name, the evaluation of argument occurs with each parameter access. Introduction

25. Programming Techniques in l-Calculus • Multiple arguments. • Church Booleans. • Pairs. • Church Numerals. • Recursion. • Extended Calculus Introduction

26. Multiple Arguments • Pass multiple arguments one by one using lambda abstraction as intermediate results. The process is also known as currying. • Example: • f = l(x,y).sf = l x. (l y. s) • Application: • f(v,w)(f v) w requires pairs as primitve types requires higher order feature Introduction

27. Church Booleans • Church’s encodings for true/false type with a conditional: • true = l t. l f. t • false = l t. l f. f • if = l l. l m. l n. l m n • Example: • if true v w • = (l l. l m. l n. l m n) true v w • ! true v w • = (l t. l f. t) v w • ! v • Boolean and operation can be defined as: • and = l a. l b. if a b false • = l a. l b. (l l. l m. l n. l m n) a b false • = l a. l b. a b false Introduction

28. Pairs • Define the functions pair to construct a pair of values, fst to get the first component and snd to get the second component of a given pair as follows: • pair = l f. l s. l b. b f s • fst = l p. p true • snd = l p. p false • Example: • snd (pair c d) • = (l p. p false) ((l f. l s. l b. b f s) c d) • ! (l p. p false) (l b. b c d) • ! (l b. b c d) false • ! false c d • ! d Introduction

29. Church Numerals • Numbers can be encoded by: • c0 = l s. l z. z • c1 = l s. l z. s z • c2 = l s. l z. s (s z) • c3 = l s. l z. s (s (s z)) • : Introduction

30. Church Numerals • Successor function can be defined as: • succ = l n. l s. l z. s (n s z) • Example: • succ c1 • = ( n.  s.  z. s (n s z)) ( s.  z. s z) • l s. l z. s ((l s. l z. s z) s z) • !l s. l z. s (s z) • succ c2 • = l n. l s. l z. s (n s z) (l s. l z. s (s z)) • !l s. l z. s ((l s. l z. s (s z)) s z) • !l s. l z. s (s (s z)) Introduction

31. Church Numerals • Other Arithmetic Operations: • plus = l m. l n. l s. l z. m s (n s z) • times = l m. l n. m (plus n) c0 • iszero = l m. m (l x. false) true • Exercise : Try out the following. • plus c1 x • times c0 x • times x c1 • iszero c0 • iszero c2 Introduction

32. However, others have an interesting property • fix = λf. (λx. f (x x)) (λx. f (x x)) • fix = l f. (l x. f (l y. x x y)) (l x. f (l y. x x y)) • that returns a fix-point for a given functional. • Given x = h x • = fix h • That is: fix h ! h (fix h) ! h (h (fix h)) ! … x is fix-point of h Recursion • Some terms go into a loop and do not have normal form. Example: • (l x. x x) (l x. x x) • ! (l x. x x) (l x. x x) • ! … Introduction

33. Example - Factorial • We can define factorial as: • fact = l n. if (n<=1) then 1 else times n (fact (pred n)) • = (l h. l n. if (n<=1) then 1 else times n (h (pred n))) fact • = fix (l h. l n. if (n<=1) then 1 else times n (h (pred n))) Introduction

34. Example - Factorial • Recall: • fact = fix (l h. l n. if (n<=1) then 1 else times n (h (pred n))) • Let g = (l h. l n. if (n<=1) then 1 else times n (h (pred n))) • Example reduction: • fact 3 = fix g 3 • = g (fix g) 3 • = times 3 ((fix g) (pred 3)) • = times 3 (g (fix g) 2) • = times 3 (times 2 ((fix g) (pred 2))) • = times 3 (times 2 (g (fix g) 1)) • = times 3 (times 2 1) • = 6 Introduction

35. Enriching the Calculus • We can add constants and built-in primitives to enrich l-calculus. For example, we can add boolean and arithmetic constants and primitives (e.g. true, false, if, zero, succ, iszero, pred) into an enriched language we call lNB: • Example: • l x. succ (succ x) 2lNB • l x. true 2lNB Introduction

36. Formal Treatment of Lambda Calculus • Let V be a countable set of variable names. The set of terms is the smallest set T such that: • x 2 T for every x 2 V • if t12 T and x 2 V, then l x. t12 T • if t12 T and t22 T, then t1 t22 T • Recall syntax of lambda calculus: • t ::= terms • x variable • l x.t abstraction • t t application Introduction

37. Free Variables • The set of free variables of a term t is defined as: • FV(x) = {x} • FV(l x.t) = FV(t) \ {x} • FV(t1 t2) = FV(t1) [ FV(t2) Introduction

38. Substitution • Works when free variables are replaced by term that does not clash: • [x al z. z w] (l y.x) = (l y. l z. z w) • However, problem if there is name capture/clash: • [x al z. z w] (lx.x) ¹ (l x. l z. z w) • [x al z. z w] (lw.x) ¹ (l w. l z. z w) Introduction

39. Formal Defn of Substitution [x a s] x = s if y=x [x a s] y = y if y¹x [x a s] (t1 t2) = ([x a s] t1) ([x a s] t2) [x a s] (l y.t) = l y.t if y=x [x a s] (l y.t) = l y. [x a s] t if y¹ x Æ y FV(s) [x a s] (l y.t) = [x a s] (l z. [y a z] t) if y¹ x Æ y 2FV(s) Æ fresh z Introduction

40. Syntax of Lambda Calculus • Term: • t ::= terms • x variable • l x.t abstraction • t t application • Value: • v ::= value • x variable • l x.t abstraction value Introduction

41. Call-by-Value Semantics premise (E-App1) conclusion (E-App2) (l x.t) v ! [x a v] t(E-AppAbs) Introduction

42. Call-by-Name Semantics (E-App1) (l x.t) t2! [x a t2] t(E-AppAbs) Introduction

43. Getting Stuck • Evaluation can get stuck. (Note that only values are l-abstraction) • e.g. (x y) • In extended lambda calculus, evaluation can also get stuck due to the absence of certain primitive rules. • (l x. succ x) true ! succ true ! Introduction

44. Boolean-Enriched Lambda Calculus • Term: • t ::= terms • x variable • l x.t abstraction • t t application • true constant true • false constant false • if t then t else t conditional • Value: • v ::= value • l x.t abstraction value • true true value • false false value Introduction

45. Key Ideas • Exact typing impossible. • if <long and tricky expr> then true else (l x.x) • Need to introduce function type, but need argument and result types. • if true then (l x.true) else (l x.x) Introduction

46. Simple Types • The set of simple types over the type Bool is generated by the following grammar: • T ::= types • Bool type of booleans • T ! T type of functions • ! is right-associative: • T1! T2! T3 denotes T1! (T2! T3) Introduction

47. Implicit or Explicit Typing • Languages in which the programmer declares all types are called explicitly typed. Languages where a typechecker infers (almost) all types is called implicitly typed. • Explicitly-typed languages places onus on programmer but are usually better documented. Also, compile-time analysis is simplified. Introduction

48. Explicitly Typed Lambda Calculus • t ::= terms • … • l x : T.t abstraction • … • v ::= value • l x : T.t abstraction value • … • T ::= types • Bool type of booleans • T ! T type of functions Introduction

49. Examples • true • l x:Bool . x • (l x:Bool . x) true • if false then (l x:Bool . True) else (l x:Bool . x) Introduction