1 / 49

CS5205: Foundation in Programming Languages Lecture 1 : Overview

CS5205: Foundation in Programming Languages Lecture 1 : Overview. “Language Foundation, Extensions and Reasoning. Lecturer : Chin Wei Ngan Email : chinwn@comp.nus.edu.sg Office : S15 06-01. Course Objectives. - graduate-level course with foundation focus

eforest
Download Presentation

CS5205: Foundation in Programming Languages Lecture 1 : Overview

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

More Related