Principles of Programming Languages

Transcription

1 Principles of Programming Languages Lecture 03 Theoretical Foundations 1

2 Domains Semantic model of a data type: semantic domain! Examples: Integer, Natural, Truth-Value Domains D are more than a set of values! Have an ``information ordering! on elements a partial order-- where x! y means (informally): ``y is as least as well-defined as x! There is a ``least defined element such that ( x)! x which represents an undefined value of the data type Or the value of a computation that fails to terminate ``bottom! Domains are complete: every monotone (non-decreasing) sequence x1! x2!!! xn!! in D has in D a least upper bound, i.e., an element denoted l = x i such that ( i) i and l is least element with this property D sometimes called a ``complete partial order or CPO x x!" l 2

3 Primitive Domains Integer (Z, Z) Natural (N, N) Truth-Value (Boolean, B, B) false true 3

4 Cartesian Product Domains D D = x y x D y D! ! bottom Truth-Value Truth-Value {(, ), } ( x, y )!( x, y ) x! x y!" y (, ) false true false true (false, false) (false, true) (true, false) (true, true) = (false,) (, false) (, true) (true, ) Generalizes to! D D D! D n (,) 4

5 Disjoint Union (Tagged Union) Domains left D + right D = left x x D right y y D left x!" left x x! x right y! right y y! y! ! bottom left Truth-Value + right Truth-Value {(, ) } {(, ) } left false true false true + right = left false left true right false right true left right 5

6 Disjoint Union Domains (cont.) Convention: tags are also names for mappings (injections) tagging operators D= left D + right D 1 2! left : D 1 left( x ) = ( left, x ) [ = left x ] right : D D D right( y ) = ( right, y ) [ = right y ]

7 Disjoint Union Domains (cont.) Example: union domains needed when data domains consist of different type elements (union types): imagine a very simple programming language in which the only things that can be named (denoted) are non-negative integer constants, or variables having such as values. Denotable = nat Natural + var Location! Dereferencing operation: Constant values dereference directly to their values Variables (locations) dereference to their contents in memory dereference : Store Denotable Natural dereference( sto, nat val) = val dereference( sto, var loc) = fetch( sto, loc) (no dependence on memory) 7

8 Sequence Domains Consist of homogenious tuples of lengths 0, 1, over a common domain D! 0 1 n+ 1 n D #{()} # Unit D # D D # D D D D D D # + + +!! Examples: Array- Value = Value String = Character! Concatenation operator : D D D ( d, d,, d ) ( e, e,, e ) = ( d, d,, d, e, e,, e ) 1 2 m 1 2 n 1 2 m 1 2 n nil = () nil x = x nil = x x D! Empty tuple nil 8

9 Functions A function f from source domain X to target domain Y is! A subset of X Y : f X Y (a relation)! Single-valued:! Source domain X! Target domain Y! Signature f : X Y Domain of f :! If X =domf then f is total ; otherwise partial To define (specify) a function, need to give! Source X! Target Y! Mapping rule x f(x) ( x, yz, ) ( xy, ) f ( xz, ) f y= z dom f = { x X y Y ( x, y) f} 9

10 Functions (cont.) Example: sq : Z sq( n)! Let R = Real. Not the same function as: sq1: R R 2 sq1( x) # x! Let N = Natural. Not the same as: sq % : N N % 2 sq() i # i Z 2 # n - fun sq(n:int):int = n*n; val sq = fn : int -> int - sq(3); val it = 9 : int - sq(1.5); stdin: Error: operator and operand don't agree [tycon mismatch] operator domain: int operand: real in expression: sq fun sq1(x:real):real = x*x; val sq1 = fn : real -> real - sq1(1.5); val it = 2.25 : real - sq1(3); stdin: Error: operator and operand don't agree [literal] operator domain: real operand:int in expression: sq1 3-10

11 Defining Functions Two views of ``mapping! Extension: view as a collection of facts square : Z Z square = {(0,0),(1,1),( 1,1)(2, 4),( 2,4)(3,9), } N N! Comprehension: view as a rule of mapping Combinator form: λ-abstraction form:! Typed λ-calculus square : Z Z # λ y : Z. y * y! In ML λ = fn. = => (λx e) = (fn x => e) square : Z Z square( x) # x* x square # λ y. y * y - fun square(x) = x*x; val square = fn : int -> int - square(4); val it = 16 : int - val square = (fn y => y*y); val square = fn : int -> int - square(5); val it = 25 : int 11

12 Defining Functions (cont.) Examples of λ-notation defining functions dist : R R R # λ( u, v). ( u v) double : Z Z # λn : Z. n + n successor : Z Z # λn : Z. n + 1 twice :( Z Z) ( Z Z) # λf :( Z Z). λn : Z. f ( f ( n)) compose :( Z Z) (( Z Z) ( Z Z)) # λf.( λg.( λn. f ( g( n)))) dist(0, ) : R R # λv. v 2 2 twice( double): Z Z # λn : Z.4 n twice( successor): Z Z # λn : Z. n + 2 ( compose( successor))( double): Z Z # λn : Z.2 n

13 Defining Functions (cont.) - val double = (fn n => n+n); val double = fn : int -> int - val successor = (fn n => n+1); val successor = fn : int -> int - val twice = (fn f => (fn n => f(f(n)))); val twice = fn : ('a -> 'a) -> 'a -> 'a - val twice = (fn f : int -> int => (fn n : int => f(f(n)))); val twice = fn : (int -> int) -> int -> int - val td = twice(double); val td = fn : int -> int - td(3); val it = 12 : int - val ts = twice(successor); val ts = fn : int -> int - ts(3); val it = 5 : int 13

14 Defining Functions (cont.) - fun double(n) = n+n; val double = fn : int -> int - fun successor(n) = n+1; val successor = fn : int -> int - fun twice(f)(n) = f(f(n)); val twice = fn : ('a -> 'a) -> 'a -> 'a - fun twice(f : int -> int )(n : int) = f(f(n)); val twice = fn : (int -> int) -> int -> int - fun td = twice(double); stdin: Error: can't find function arguments in clause - twice(double)(3); val it = 12 : int - twice(successor)(3); val it = 5 : int - fun compose(f)(g)(n) = f(g(n)); val compose = fn : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b - val csd = compose(successor)(double); val csd = fn : int -> int - csd(3); val it = 7 : int 14

15 Function Domains Elements are functions from a domain to 1 2 another Domain of functions denoted Not all functions must be monotone: if! Idea: more info about argument more info about value Ordering on domain Bottom element of domain! totally undefined function f : D D D1 D2 (or [ D1 D2] ) f D1 D2 xy, D x! y f( x)! f( y) 1 D 1 2 D1 D2 f! D ( 1 D g x D 2 1 f ( x)! D g( x) 2 D1 D2 # λx. Technical requirement: functions must be continuous: monotone chains x! x!! f( x ) = f( x ) D D D D i i 15

16 Function Domains (cont.) (Truth-Value Unit) f false true ( ) t f t ( ) ( ) Models procedures (void functions) that take a boolean and return, or not f f t ( ) t ( ) f?? f t ( ) t ( ) 16

17 Function Domains (cont.) (Truth-Value Truth-Value) Exercise! Be careful about monotonicity! false true false true 17

18 λ-calculus Let e be an expression containing zero or more occurrences of variables x1, x2,, xn Let ea [ / x] denote the result of replacing each occurrence of x by a The lambda expression! Denotes (names) a function λ x x x e 1 2 n.! Value of the λ-expression is a function f such that aa 1 2 an f( a1, a2,, an) = value of expression ea [ / x, a / x,, a / x] ! Provides a direct description of a function object, not indirectly via its behavior when applied to arguments n n 18

19 λ-calculus Examples Example: sq sq = ``that function that if applied to a results in = λx.( x x) a a'' Example: zval zval = ``the functional that when applied to function f results in f(0)'' = λ f. f (0) Example: compose = ``the functional that when applied to functions f and g results in the funtion λx. f( g( x))'' compose = λf.( λg.( λx.( f ( g( x))))) 19

20 λ-calculus Examples (cont.) Functionals: functions that take other functions as arguments or that return functions; also highertype functions Example: the definite integral Example: the indefinite integral 3 0 x 2 x udu= :( R R ) ( R R ) x 2 x ( λzz. ) = λx. = λf. λx. f( u) du :( R R ) R = λ f. f( u) du f( u) du ( f : R R ) 0 x f ( u ) du ( f : R R ) ( ) 20

21 λ-calculus Examples (cont.) Example: integration routine trapezoidal : R R R ( R R ) R [( b a)/ n] trapezoidal = λhabf. h f ( a + i h) ( f ( a) + f ( b))/2 i= 0 Example: summation operator n :( N R ) R n n nn ( λm.1) = n+ 1 ( λmm. ) = :( N R ) ( N R ) ( λm.1) = λn.( n+ 1) n f() i ( f : N R ) i= 0 ( + 1) 2 21

22 λ-calculus Examples (cont.) Example: derivative operator n n 1 2 Dx = nx D3 = 0(!) D :( R R ) ( R R ) ( ) ( ) n n 1 D λxx. = λxnx. Example: indexing operator Postfix [i]: IntArray Integer [i]= λa.a[i] Example: funcall or apply operator! Signature apply :( A B) A B! Combinator definition apply( f )( a) = f ( a)! Lambda definition apply = λf. λa. f ( a) 22

23 Currying (Curry 1945;Schönfinkel 1924) Transformation reducing a multi-argument function to a cascade of 1-argument functions curry :( X Y Z) ( X ( Y Z) f :X Y Z curry( f ):( X Y) Z f = λ( xy, ). f( xy, ) curryf ( ) = λx. λyf. ( xy, ) curry = λf. λx. λy. f ( x, y) Examples curry(" ") = λx. λy.( x y) [" " = λ( x, y)( x y)] curry(" ")(3) = λ y.(3 y) curry("*")(2) = λz.(2 z) = double Applying curry(f) to first argument a yields a partially evaluated function f of its second argument: f(a,-) λ yf. ( ay, ) 23

24 Currying (cont.) Example: machine language curries += λa. λb.( a+ b)! Assume contents(a)=a and contents(b)=b LDA A r0 = λa. λb.( a+ b) ADD B } r0= λb.( a+ b) 24

25 λ-calculus Syntax Lambda=expression Id=identifier Ab=abstraction Ap=application Lambda Id Ab Ap Ab (λ Id. Lambda) Ap (Lambda Lambda) Id x y z Examples (( xy) z) ( fx) ( λx.( λy.( λz.(( xy) z) ))) ( λx.( λy. x)) ( λx.( λy.( λz.( x( yz)) ))) ( λx.( λy.( sqrt(( plus( square x))( square y))))) 25

26 λ-calculus: simplified notation Conventions for dropping () disambiguation needed Rules for dropping parentheses! Application groups L to R xyz #(( xy) z) x( yz) #( x( yz))! Application has higher precedence than abstraction λxyz. #( λx.( yz)) ( λxy. ) z# (( λxy. ) z)! Abstraction groupts R to L! Consecutive abstractions collapse to single λ! Example: λx. λy. λze. # ( λx.( λy.( λze. ))) λxyz. e # λx. λy. λz. e S # ( λx.( λy.( λz.(( xz)( yz))))) S = λxyz.( xz)( yz) = λxyz. xz( yz) λxyz.( xz) yz = ( λx.( λy.( λz.((( xz) y) z)))) 26

27 Variables: Free, Bound, Scope Metavariables: I: Id L: Lambda Type the semantic function occurs: Lambda (Id B) one rule per syntactic case (syntax-driven)!! " are traditional around syntax argument & ' occurs I x= ( I = x) & λ. ' x= & ' occurs I L occurs L & ' = & ' & ' occurs L L x occurs L x occurs L x x Note: In expession λx.y the variable x does not occur! 27

28 Variables: Free, Bound, Scope (cont.) occurs_bound : Lambda (Id B) & ' occurs _ bound I x = false occurs_free : Lambda (Id B) & λ ' = = & ' occurs _ bound I. L x ( x I) occurs _ free L x & ' x= _ & ' occurs _ bound L L occurs bound L & ' occurs _ free I x= ( I = x) & occurs _ bound L & λ ' = & ' occurs _ free I. L x ( x I) occurs _ free L x & ' x= _ & ' occurs _ free L L occurs free L occurs _ & free L 2 x ' 2 ' x x x 28

29 Variables: Free, Bound, Scope (cont.) The notions free x, bound x, occur x are relative to a given expression or subexpression Examples:!!! ( λu.( λxux. ) xu) ( λ xy. ) ( λx.( λy. y)) 29

30 Variables: Scope The scope of a variable x bound by an λx prefix in an abstraction (λx.e) consists of all of e excluding any abstraction subexpressions with prefix λx! these subexpressions are known as holes in the scope! Any occurrence of x in scope is said to be bound by the λx prefix Example Bindings: λy. λz. x ( z ( y ( λy. y z) ) y ) Scopes: i λy λzi x ( z ( y ( λyi y z) ) y ) hole in scope 30

31 λ-calculus: formal computation reduction rules α-conversion: formal parameter names do not affect meaning! Ex: β-reduction: models application of a function abstraction to its argument! Ex: λx. e λye. [ y/ x] α substitute y for free occurrences of x in e (rename of clash occurs) λx. λza. ( xz) λx. λz. a( xz ) α λ z. λzazz. ( ) λz. λxazx. ( ) α α ( λx. ea ) ea [ / x] redex ( λx. λy. x) a(( λxxx. )( λxxx. )) β contractum ( λya. )(( λxxx. )( λxxx. )) a β β 31

32 λ-calculus: formal computation (cont.) η-reduction: models extensionality λx. ex e η! Ex: x not free in e (no other x occurrences in scope) λv.( λxx. ( λxux. )) v η λv.( λ xxu. ) v ( λxx. ( λxux. )) η η ( λxxu. ) η ( λxxu. ) 32

33 Reduction is locally non-deterministic ( λu. λv.( λww. ( λxxu. )) v) y β ( λu. λvv. ( λ xxu. )) y λv.( λww. ( λxxy. )) v β β β λvv.( λ xxy. ) λvv.( λxxy. )? 33

34 Normal Forms Identify α-equivalent expressions Reduction: Reduction as far as possible : Defn: Normal Form: an expression that cannot be further reduced by λz.( λxx. ) z(( λxx. ) z) β λzz.(( λ xx.)) z λz.( λxx. ) z z β # # ( ) β η ( ) β λz. zz β 34

35 Normal Forms Don t Always Exist Parallel of non-terminating computation Example: self-application combinator : What happens with SELF # λx. xx ( SELF SELF) = (( λx. xx)( λx. xx))? (( λxxx. )( λzzz. )) β ( λzzz. )( λzzz. ) Ω # ( SELF SELF) = (( λx. xx)( λx. xx)) # β 35

36 Computation Rules Leftmost Innermost (LI): among the innermost nested redexes, choose the leftmost one to reduce Leftmost Outermost(LO): among the outermost redexes, choose the letmost one to reduce (( λ yz.(( λ x. x) z)( yz))( λ x. x))( λ w. a) LO LI (( λ yz.( z( yz))( λ x. x))( λ w. a) ( λ z.(( λ xx. ) z)(( λ xx. ) z))( λ wa. ) ( λ z. z(( λ x. x) z))( λ w. a) (( λ x. x)( λ w. a))(( λ x. x)( λ w. a)) ( λ z. zz)( λ w. a) ( λ wa. )(( λ xx. )( λ wa. )) ( λ wa. )( λ wa. ) a 36

37 β vs η --very different β-reduction: abstract e, then apply ( λxe. ) x parse η-reduction: apply e, then abstract λxex. parse no restriction on e (( λ xe. ) x) ( λx.( ex)) β η not η-redex not β-redex β η only if e free of x ex [ / x] Example: ((lambda (x) 1+) x) 1+ e Example: (lambda (x) (1+ x)) 1+ 37

38 Mixed β and η reductions λv. ( λx. x( λxux. ) ) v parse ( λv. (( λx.( x ( λxux. )) ) v) ) ( λv.(( λx.( x u) ) v) ) η β ( λv.( v ( λx.( ux)) ) ) β ( λv.( vu)) η 38

39 Church-Rosser: ultimate determinism Church-Rosser Theorem P M Q R M, PQ, M P & M Q R P R & Q R Corollary: If a normal form exists for an expression, it is unique (up to α-equivalence) 39

40 Church-Rosser: says reduction, not forced ( λx. a)( SELF SELF) = ( λxa. )(( λxxx. )( λxxx. )) LO LI a ( λxa. )( SELF SELF) LO LI a LO Correct computation rule: if a normal form, it will be computed ex: LO a ( λxa. )( SELF SELF) LI LO a ( λxa. )( SELF SELF) LI $ Incorrect (but efficient): ex: LI LO = normal rule = CBN = lazy Prog Lang: Haskell LI = applicative rule = CBV=eager Prog Lang: Scheme 40

41 Correct Computation Rule A rule is correct if it calculates a normal form, provided one exists Theorem: LO (normal rule) is a correct computation rule.! LI (applicative rule) is not correct gives the same result as normal rule whenever it converges to a normal form (guaranteed by the Church-Rosser property)! LI is simple, efficient and natural to implement: always evaluate all arguments before evaluating the function! LO is very inefficient: performs lots of copying of unevaluated expressions 41

42 Typed λ-calculus More restrictive reduction. No SELF = ( λx. xx) Type ::= (Type Type) PrimType Lambda ::= Id (Lambda Lambda) (λ Id : Type. Lambda) Id ::= x y z PrimType ::= int Type Deduction Rules ) M : σ τ ) N : σ (axiom) (appl) ) x : τ ) ( MN): τ ) M : τ ) x : σ (abst) ) ( λx: σ. M): σ τ E is type correct iff a type α such that ) E : α Thm: Every type correct expression has a normal form 42

43 Typed λ-calculus (cont.) Example: SELF = ( λx. xx) is not type correct! Work backward using rules. Assume ) λx : α. xx : α β &) x : γ )( xx): β ) x: α ) λx: α.( xx): α β γ = α ) x: α &( xx): β ) x : δ β ) x : δ ) ( xx): β ) x : δ &) x : α δ = α ) x: δ β & ) δ = α ) x: α β ) x: α &) x: α β α = ( α β )! So a contradiction. Therefore there is no consistent type assignment to SELF = ( λx. xx) 43

44 Typed λ-calculus (cont.) Example: type the expression! Work forward ) f : α β ) x : α ) ( fx): β )( fx): β ) x: α ) λx: α.( fx): α β (appl) (abst) λf. λxfx. ) λx : α.( fx): α β ) f : α β ) ( λf : α β.( λx: α.( fx))) : ( α β ) ( α β ) (abst) 44

45 λ-calculus: History Frege 1893: unary functions suffice for a theory Schönfinkel 1924:! Introduced currying! Combinators KAB # A SABC # AC(BC)! Combinatory (Weak) Completeness: all closed λ-expressions can be defined in terms of K,S using application only: Let M be built up from λ, K,S with only x left free. Then an expression F built from K,S only such that Fx=M Curry 1930: K # λab. a S# λabc. ac( bc)! introduced axiom of extensionality:! Weak Consistency: K=S is not provable X FX = GX F = G 45

46 λ-calculus: History (cont.) Combinatory Completeness Example:! Composition functional: BXYZ # X(YZ) B #λ fgx. f ( gx)! Thm: B = S(KS)K! Prf: Note that K # λxy. x KS= ( λxyx. ) S= λy. S So S(KS) = ( λxyz. xz( yz))( KS) = ( λyz.(( KS) z)( yz)) and so = ( λyz.(( λy. S) z))( yz) = λyz. S( yz) S(KS)K = ( λyz. S( yz)) K = λz. S( Kz) = λz. S( λy. z) α = λv.( S λwv.) = λv.( λxyz. xz( yz))( λwv.) = λv.( λyz.( λwv. ) z( yz)) = λv.( λyzv. ( yz)) = λv. λy. λzv. ( yz) = λf. λg. λx. f( gx) * Exercise: define C # λxyx. xzy & show C = S(BBS)(KK) α 46

47 λ-calculus: History (cont.) Church 1932:! If Fx=M call F λx.m! Fixed Point Theorem: Given F can construct a Φ such that Φ=FΦ! Discovered fixed point (or paradoxical ) combinator: Y # λf.( λx. f ( xx))( λx. f ( xx))! Exercise: Define Φ=YF and show by reduction that Φ=FΦ Church & Rosser 1936: strong consistency Church- Rosser Property.! Implies that α-equivalence classes of normal forms are disjoint! provides a syntactic model of computation Martin-Löf 1972: simplified C-R Theorem s proof 47

48 λ-calculus: History (cont.) Church 1932: Completeness of the λ-calculus! N can be embedded in the λ-calculus n# λf. λx. f( f(...( f x)...)) +,-,. n! Church 1932/Kleene 1935: recursive definition possible: F(1) = GA K-C-G ``general recursion'' Fn ( + 1) = GFn ( ) Thm : F is ``λ-definable'': F = λx. xga (!)! Check: F1 = ( λx. xga)1 1 GA ( λf. λx. fx) GA ( λxgx. ) A GA F2 2 GA ( λf. λx. f( fx)) GA ( λx. G( Gx)) A G( GA) 48

49 λ-calculus: History (cont.) Church-Rosser Thm (1936) λ-calculus functions are ``computable (aka ``recursive ) Church s Thesis: The ``effectively computable functions from N to N are exactly the λ-calculus definable functions a strong assertion about completeness ; all programming languages since are complete in this sense Evidence accumulated! Kleene 1936: general recursive λ-calculus definable! Turing 1937: λ-calculus definable Turing-computable! Post 1943, Markov 1951, etc.: many more confirmations! Any modern programming language 49

50 λ-calculus: History (cont.) Is the untyped λ-calculus consistent? Does it have a semantics? What is its semantic domain D?! want data objects same as function objects: since λ xmx. = M D= D! Trouble: impossible unless D =1 because! Troublesome self-application paradoxes: if we define then η τ = λ y. if y( y) = a then b else a τ ( τ) = if τ( τ) = a then b else a! Dana Scott 1970: will work if we have the D monotone (and continuous) functions of D! Above example: τ is not monotone τ ( λx. ) = if = a then b else a= a τλ ( xa. ) = if a= athen belse a = b λx.! λxa. but a! b D D < D D = D [ ] D= D D D 50

51 false false false true (false, false) (false, true) (true, false) (true, true) (false,) false (, false) false (, true) (true, ) (,) 51