CS5205: Foundation in Programming Languages Lecture 1 : Overview

1
CS5205 Foundation in Programming Languages
Lecture 1 Overview
Language Foundation, Extensions and Reasoning

Lecturer Chin Wei Ngan Email
chinwn_at_comp.nus.edu.sg Office S15 06-01
2
Course Objectives
- graduate-level course with foundation focus
- languages as tool for programming -
foundations for reasoning about programs -
explore various language innovations
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)

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

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
7
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)))
• gt (Cons 2 (Cons 3 (Cons 4 Nil)))

a type variable
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.

9
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?

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

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/downl
oad.html
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).

13
Functions without Names
Usually functions are given a name (e.g. in
language C) int plusOne(int x) return x1
plusOne(5) However, function names can also
be dropped (int (int x) return x1 )
(5) Notation used in untyped lambda
calculus (l x . x1) (5)
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!
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

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

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)

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 ) t2 is called a
  redex (reducible expression).

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

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
• !

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
• !

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
• !

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
• !

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.

25
Programming Techniques in l-Calculus

• Multiple arguments.
• Church Booleans.
• Pairs.
• Church Numerals.
• Recursion.
• Extended Calculus

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).s f l x. (l y. s)

Application f(v,w) (f v) w
requires pairs as primitve types
requires higher order feature
27
Church Booleans

• Churchs 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

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

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

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

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

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

33
Example - Factorial

• We can define factorial as
• fact l n. if (nlt1) then 1 else times n (fact
  (pred n))
• (l h. l n. if (nlt1) then 1 else times n (h
  (pred n))) fact
• fix (l h. l n. if (nlt1) then 1 else times n
  (h (pred n)))

34
Example - Factorial

• Recall
• fact fix (l h. l n. if (nlt1) then 1 else
  times n (h (pred n)))
• Let g (l h. l n. if (nlt1) 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

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) 2 lNB
• l x. true 2 lNB

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 t1 2 T and x 2 V, then l x. t1 2 T
• if t1 2 T and t2 2 T, then t1 t2 2 T
• Recall syntax of lambda calculus
• t terms
• x variable
• l x.t abstraction
• t t application

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)

38
Substitution

• Works when free variables are replaced by term
  that does not clash
• x a l z. z w (l y.x) (l y. l z. z w)
• However, problem if there is name capture/clash
• x a l z. z w (l x.x) ¹ (l x. l z. z w)
• x a l z. z w (l w.x) ¹ (l w. l z. z w)

39
Formal Defn of Substitution
x a s x s if yx 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 yx 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 2 FV(s) Æ fresh
z
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

41
Call-by-Value Semantics
premise
t1 ! t1
t1 t2 ! t1 t2
(E-App1)
conclusion
t2 ! t2
v1 t2 ! v1 t2
(E-App2)
(l x.t) v ! x a v t (E-AppAbs)
42
Call-by-Name Semantics
t1 ! t1
t1 t2 ! t1 t2
(E-App1)
(l x.t) t2 ! x a t2 t (E-AppAbs)
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 !

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

45
Key Ideas

• Exact typing impossible.
• if ltlong and tricky exprgt 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)

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)

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.

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

49
Examples
true l xBool . x (l xBool . x) true
if false then (l xBool . True) else (l xBool
. x)