Extending the Lambda Calculus: An Eager Functional Language

Transcription

1 Syntax of the basic constructs: Extending the Lambda Calculus: An Eager Functional Language canonical forms z cfm ::= intcfm boolcfm funcfm tuplecfm altcfm intcfm ::= boolcfm ::= boolconst funcfm ::= λvar. exp tuplecfm ::= cfm,... cfm altcfm tag cfm boolconst ::= true false natconst ::= expressions e exp ::= natconst -exp exp + exp... boolconst exp exp exp... if exp then exp else exp funcfm var exp exp exp,... exp tag exp sumcase exp of (exp,... exp) error typeerror labels (tags) k tag ::= natconst

2 Syntactic Sugar: Definitions and Patterns Syntax of derived forms: funcfm ::=... λpat. exp exp ::=... let pat exp,... pat exp in exp patterns p pat ::= var pat,... pat Semantics of the derived forms: let p 1 e 1,... p n e n in e Example: λ p 0,... p n 1. e def = (λp λp n. e) e 1... e n def = λv. let p 0 v.0,... p n 1 v. n 1 in e where v / F V (e) let x, y 1, 2 in x+y = (λ x, y. x+y) 1, 2 = (λz. let x z.0, y z.1 in x+y) 1, 2 = (λz. (λx. λy. x+y) (z.0) (z.1)) 1, 2

3 Semantics of the Basic Constructs z z e i -e i e i e i e + e i + i e true e z if e then e else e z e λv. e 0 e z (e 0 /v z ) z e e z e b e b e b e b e e b b e false e z if e then e else e z e 1 z 1... e n z n e 1,... e n z 1,... z n e z 0,... z n 1 e.k z k if k < n e k k z k z e k z z sumcase e of (e 0,... e n 1 ) z if k < n

4 Recursion In the untyped language we can define recursive functions using the (eager) fixed-point combinator Y v. But in a simple typing discipline Y v is not typable. One solution: a special construct for recursive definitions: exp ::=... letrec var λpat. exp,... var λpat. exp in exp with the reduction rule Syntactic sugar: (λv λv n 1. e) (λu 0. e 0 )... (λu n 1. e n 1 ) z letrec v 0 λu 0. e 0,... v n 1 λu n 1. e n 1 in e z where e def i = letrec v 0 λu 0. e 0,... v n 1 λu n 1. e n 1 in e i and {v 0,...} {u 0,...} = {} letrec v 0 p 0 e 0,... in e def = letrec v 0 λp 0. e 0,... in e

5 Programming in the Eager Functional Language Recall the reduction rule for letrec: (λv λv n 1. e) (λu 0. e 0 )... (λu n 1. e n 1 ) z letrec v 0 λu 0. e 0,... v n 1 λu n 1. e n 1 in e z where e def i = letrec v 0 λu 0. e 0,... v n 1 λu n 1. e n 1 in e i and {v 0,...} {u 0,...} = {}

6 An Example: Generating a List letrec f λn. if n = n, f (n-1) }{{} e (λf. f 3) (λn. letrec f λn. e in e) (λn. letrec f λn. e in e) 3 in f 3 letrec f λn. e in if 3 = , f (3-1) (λf. if 3 = , f (3-1) ) (λn. letrec f λn. e in e) if 3 = , (λn. letrec f λn. e in e) 1 3, (λn. letrec f λn. e in e)

7 Derived Data Types: Lists Following Standard ML s syntax for lists... e 1 ::e 2 ::... ::e n ::nil case e of nil => e x::xs => e... we can extend the language with exp ::=... nil exp::exp constructors listcase exp of (exp, exp) deconstructor cfm ::= nil cfm::cfm

8 Evaluation semantics: Semantics and Encoding of Lists nil nil e nil e z listcase e of (e, e ) z e 1 z 1 e 2 z 2 e 1 ::e 2 z 1 ::z 2 e z 1 ::z 2 e z 1, z 2 z listcase e of (e, e ) z Encoding of lists in terms of products and sums: nil def 0 e 1 ::e 2 def 1 e 1, e 2 listcase e of (e, e ) def = sumcase e of (λ. e, e ) Note: LISP-style languages define a tester null? and deconstructors car and cdr but car and cdr are not well-defined on nil.

9 List Processing Some functions from the list libraries of ML and Haskell expressed in our eager functional language: letrec append λxs. λys. listcase xs of (ys, λ x, xs. x::append xs ys) in letrec map λf. λxs. listcase xs of (nil, λ x, xs. f x::map f xs ) in letrec foldr λf. λz. λxs. listcase xs of (z, λ x, xs. f x (foldr f z xs )) in letrec revappend λxs. λys. listcase xs of (ys, λ x, xs. revappend xs (x::ys)) in let map λf. foldr (λx. λys. f x::ys) nil, append λxs. λys. foldr (λz. λzs. z::zs) ys xs, rev λxs. revappend xs nil, append λxs. revappend (rev xs) in...

10 Direct Denotational Semantics Let the predomain of values be V φ ψ V int + V bool + V fun + V tup + V alt, where V int = Z V bool = B V fun = [V V ] V tup = n=0 V n V alt = N V with injections and the domain of results is V = (V + {error, typeerror}) : ι norm = ι ι 0 [V V ] err = ι (ι 1 error) V tyerr = ι (ι 1 typeerror) V ι int = ψ ι 0 [V int V ] ι bool = ψ ι 1 [V bool V ] ι fun = ψ ι 2 [V fun V ] ι tup = ψ ι 3 [V tup V ] ι alt = ψ ι 4 [V alt V ] Then [[ ]] exp E V, where E = var V is the predomain of environments: [[error]]η = err [[typeerror]]η = tyerr [[ n ]]η = ι norm (ι int n)

11 Direct Denotational Semantics cont d [[-e]]η = (λn Z. ι norm (ι int ( n))) int ([[e]]η) f int def = (f int ) where the lift ( ) from [V V ] to [V V ] is f (ι norm z) = f z f err = err f tyerr = tyerr and we define a type-checking lift ( ) int of functions from [V int V ] to [V V ]: f int (ι int n) = f n f int z = tyerr for other z V ( ) bool, ( ) fun, ( ) tup, and ( ) alt are defined similarly, and from them ( ) bool etc.

12 Denotational Semantics of Binary Operations [[e+e ]]η = ( λn Z. (λn Z. ι norm (ι int (n + n ))) int ([[e ]]η) ) int ([[e]]η) Note: this semantics evaluates e+e from left to right the symmetry of + from the expression language is broken either of e and e may fail (err or tyerr) or diverge If [[e]]η = and [[e]] η = tyerr, then [[e+e ]]η = [[e +e]]η = tyerr

13 Runtime Errors One approach to introducing types: Consider sets of values closed under the semantics of certain language constructs, e.g. integers are closed under the semantics of +, -, *. But operations like the division are not defined on all values in a type. We could consider more fine-grained types, e.g. the set { n, n n Z, n Z {0}}, but a type system which infers them would be undecidable. The prevailing approach is to defer the check for definedness until run time, and signal an error if undefined: [[e e ]]η = (λn Z. (λn Z. if n = 0 then err else ι norm (ι int (n n ))) int ([[e ]]η)) int ([[e]]η)

14 Functions, Tuples, Alternatives [[v]]η = ι norm (η v) [[e e ]]η = (λf [V fun V ]. (λz V. f z) ([[e ]]η)) fun ([[e]]η) [[λv. e]]η = ι norm (ι fun (λz V. [[e]][η v : z])) [[ e 1,... e n ]]η = (λz 1 V.... (λz n V. ι norm (ι tup z 1,... z n )) ([[e n ]]η)... ) ([[e 1 ]]η) [[e.k]]η = (λz V. if k dom z then ι norm (z k) else tyerr) tup ([[e]]η) [[@ k e]]η = (λz V. ι norm (ι alt k, z )) ([[e]]η) [[sumcase e of (e 0,... e n 1 )]]η = (λ k, z N V. if k < n then (λf [V V ]. f z) fun ([[e k ]]η)

15 The reduction rule for letrec Semantics of letrec (λv λv n 1. e) (λu 0. e 0 )... (λu n 1. e n 1 ) z letrec v 0 λu 0. e 0,... v n 1 λu n 1. e n 1 in e z where e def i = letrec v 0 λu 0. e 0,... v n 1 λu n 1. e n 1 in e i and {v 0,...} {u 0,...} = {} suggests that the semantic equation is [[letrec v 1 λu 1. e 1,... v n λu n. e n in e]]η = [[e]]η where η = [η v 1 : [[λu 1. e 1 ]]η... v n : [[λu n. e n ]]η ] The last equation is ill-formed: η E = var V, while [[λu 1. e 1 ]]η V, however the r.h.sides are restricted syntactically to be values, and [[λu i. e i ]]η = ι norm (ι fun (λu i V. [[e i ]][η u i : z])) so we can use directly the corresponding element of V : η = [η v 1 : ι fun (λu 1 V. [[e 1 ]][η u 1 : z])... v n : ι fun (λu n V. [[e n ]][η u n : z])]

16 Semantics of letrec cont d One remaining problem: the equation η = [η v 1 : ι fun (λu 1 V. [[e 1 ]][η u 1 : z])... v n : ι fun (λu n V. [[e n ]][η u n : z])] cannot be solved using the least fixed-point operator Y because E = var V is a predomain, not a domain. But we can break the loop at a different point, where the value is in a domain: in the case of n = 1 f is in V fun, which is a domain, hence η = [η v : ι fun f] where f = λu V. [[e]][η u : z] hence f = λu V. [[e]][η v : ι fun f u : z] f = Y Vfun (λg V fun. λu V. [[e]][η v : ι fun g u : z]).