CSE-321 Programming Languages

(So Many Topics)

POSTECH

May 29, 2006

박성우

2

Outline for Today's Lecture• Existential types• Dependent types• Call-by-name and call-by-need• CPS (Continuation-passing style) transformation• Constructive logic• Curry-Howard isomorphism• Module system of Standard ML• -calculus• LF type theory• Twelf for mechanizing proofs

3

List Reversal in TML

datatype list = Nil | Cons of (int * list);

val rec append = fn Nil => (fn x => Cons (x, Nil)) | Cons (h, t) => (fn x => Cons (h, append t x));

val rec reverse = fn Nil => Nil | Cons (h, t) => append (reverse t) h;

val l = Cons (1, Cons (2, Cons (3, Cons (4, Nil))));

val id = fn x => x;

id reverse l

4

Data Constructors in TML

datatype list = Nil | Cons of (int * list);

val rec append = fn Nil => (fn x => Cons (x, Nil)) | Cons (h, t) => (fn x => Cons (h, append t x));

val rec reverse = fn Nil => Nil | Cons (h, t) => append (reverse t) h;

val l = Cons (1, Cons (2, Cons (3, Cons (4, Nil))));

val id = fn x => x;

id reverse l

5

Patterns in TML

datatype list = Nil | Cons of (int * list);

val rec append = fn Nil => (fn x => Cons (x, Nil)) | Cons (h, t) => (fn x => Cons (h, append t x));

val rec reverse = fn Nil => Nil | Cons (h, t) => append (reverse t) h;

val l = Cons (1, Cons (2, Cons (3, Cons (4, Nil))));

val id = fn x => x;

id reverse l

6

More Patterns in TML

datatype list = Nil | Cons of (int * list);

val rec append = fn Nil => (fn x => Cons (x, Nil)) | Cons (h, t) => (fn x => Cons (h, append t x));

val rec reverse = fn Nil => Nil | Cons (h, t) => append (reverse t) h;

val l = Cons (1, Cons (2, Cons (3, Cons (4, Nil))));

val id = fn x => x;

id reverse l

7

Patterns

val _ = 1;

val true = true;

val Cons (h, t) = Cons (1, Nil);

val (x, y) = (1, ~1);

val (x) = 1;

val (x : int) = 1;

8

Match Rule : pat => exp

datatype list = Nil | Cons of (int * list);

val rec append = fn Nil => (fn x => Cons (x, Nil)) | Cons (h, t) => (fn x => Cons (h, append t x));

val rec reverse = fn Nil => Nil | Cons (h, t) => append (reverse t) h;

val l = Cons (1, Cons (2, Cons (3, Cons (4, Nil))));

val id = fn x => x;

id reverse l

9

Outline• Patterns in TML V• Syntax of TML• Typing and translation

10

Syntax for TML• scontype  ::= int  |  bool  |  unit• sconpat  ::= num  |  true  |  false  |  ()• scon  ::= num  |  true  |  false  |  ()  • op  ::= +  |  -  | *  |  =  |  <>• ty  ::= scontype  |  tycon  |  (ty * ty)  | (ty -> ty)  |  (ty)• pat  ::= _  |  sconpat  |  vid <pat>  |  (pat, pat)  |  (pat)  |  (pat : ty)• num  ::= <integer constants>• tycon  ::= <alphanumeric identifiers>• vid  ::= <alphanumeric identifiers>• conbinding  ::= vid <of ty>• conbind  ::= conbinding <| conbind>• dec  ::= val pat = exp  |  val rec pat = exp  |  datatype tycon = conbind• mrule  ::= pat => exp• match  ::= mrule <| match>• exp  ::= scon  |  vid  |  (exp, exp)  |  let dec in exp end   | (exp)  |  exp exp   | 

exp op exp   |  (exp : ty) | fn match• dlist  ::= <dec;>*• program  ::= dlist exp

11

Types• scontype  ::= int  |  bool  |  unit

• tycon  ::= <alphanumeric identifiers>

• ty  ::= scontype  |  tycon  |  (ty * ty)  | (ty -> ty)  |  (ty)

12

Patterns• sconpat  ::= num  |  true  |  false  |  ()

• vid  ::= <alphanumeric identifiers>

• pat  ::= _  |  sconpat  |  vid <pat>  |  (pat, pat)  |  (pat)  |  (pat : ty)

13

Declarations• vid  ::= <alphanumeric identifiers>• conbinding  ::= vid <of ty>• conbind  ::= conbinding <| conbind>• dec  ::= 

val pat = exp  |  val rec pat = exp  |  datatype tycon = conbind

14

Expressions and Programs • scon  ::= num  |  true  |  false  |  ()  • op  ::= +  |  -  | *  |  =  |  <>• mrule  ::= pat => exp• match  ::= mrule <| match>• exp  ::= 

scon  |  vid  |  (exp, exp)  |  let dec in exp end   |(exp)  |  exp exp   | exp op exp   |  (exp : ty)

| fn match• dlist  ::= <dec;>*• program  ::= dlist exp

15

Outline• Patterns in TML V• Syntax of TML V• Typing and translation

16

Monomorphic Typing• No polymoprhic types, i.e., no type variables

– every expression has a unique monomorphic type

val id = fn x => x;

id 1

17

Typing and Translation• Ast.program

– source program• Core.programty

– program with type annotations• Mach.code

– machine code

• val tprogram : Ast.program -> Core.programty

• val programty2code : Core.programty -> Mach.code

18

50% of Assignment 8type venv = (avid, loc) dicttype env = venv * int

val pat2code : Mach.label * Mach.label * loc -> Core.pat ->

Mach.code * venv val exp2code :

env * Mach.label -> Core.exp -> Mach.code * Mach.rvalue

val dec2code : env * Mach.label -> Core.dec ->

Mach.code * env val matchty2code :

env * Mach.label -> Core.matchty -> Mach.code

19

The Remaining 49%• Representation for functions• Representation for recursive functions• Context switch• Function arguments and return values

) These questions test your understanding of closures.

20

The Remaining 1%• Representation for pairs• Representation for data constructors• Registers• Heap• Optimizations

• 하면서 보내 버리는 시간

• ...

Advice on Assignment 8

22

• Don't get scared by Parjong's misleading message on the discussion board.

제 목 : 허허허 .. ㅠ _ ㅠ교수님 HW8.. 도저히 .. -_-aa 그 시간에 끝낼 수 있을

거라는 생각이 안드는데요 ;;

– Everyone of you can finish this assignment!

23

• Assignment 8– will be the most fun of all the assignments this

course offers.– will be the most rewarding experience you can

have in this course.

• Discuss with your classmates (not just with your partner)

• Start early!

• Sample solution: about 600 lines of code– You will write 300 ~ 500 lines of code.