Dynamic Data Types - Recursive Records

Size: px

Start display at page:

Download "Dynamic Data Types - Recursive Records"

Ralph Richard
5 years ago
Views:

1 Dynamic Data Types - Recursive Records Example: class List { int hd; List tl ;} J.Carette (McMaster) CS 2S03 1 / 19

2 Dynamic Data Types - Recursive Records Example: class List { int hd; List tl ;} Note: int List is only non-empty lists (of integers) but List {empty list} (int List) Observe: List is a record and its value is a reference, a reference can be null. So, List {null} (int List) J.Carette (McMaster) CS 2S03 1 / 19

3 Recursive Records - Example List l; l = new List (); l. hd = 4; l.tl = new List (); l.tl.hd = 5; l.tl.tl = null ; J.Carette (McMaster) CS 2S03 2 / 19

4 Recursive Records - Example - Cont. ll! l! l! 0! 0 44! (1)! (2)! (3)! l! 44! 0! 0 ll! (4)! 44! 05! (5)! J.Carette (McMaster) CS 2S03 3 / 19

5 Recursive Records - Constructor List ( final int x, final List y) { this. hd = x; this. tl = y;} List l = new List (4, new List (5, null )); J.Carette (McMaster) CS 2S03 4 / 19

6 Recursive Definitions and Fixed Point Equations List {null} int List is not a definition but an equation to be solved! J.Carette (McMaster) CS 2S03 5 / 19

7 Recursive Definitions and Fixed Point Equations List {null} int List is not a definition but an equation to be solved! How? To construct a solution we proceed by successive approximations: Let i be the number step of approximation and L i the solution at the step i. L 0 = L 1 = {null} (int L 0 ) = {null} L 2 = {null} (int L 1 ) = {null} (int {null}) L 3 = {null} (int L 2 ) = {null} (int {null}) (int (int {null})). List := lim i L i J.Carette (McMaster) CS 2S03 5 / 19

8 Infinite Values The type List contains values that cannot be constructed in a finite number of steps. For example: List l = new List (); l. hd = 4; l. tl = l; Creates the following list: ll! 44! J.Carette (McMaster) CS 2S03 6 / 19

9 Infinite Values The type List contains values that cannot be constructed in a finite number of steps. For example: List l = new List (); l. hd = 4; l. tl = l; Creates the following list: ll! 44! The following program terminates properly if you apply it to finite lists, but enters an infinite loop if you try to apply it to infinite lists. static int sum ( final List l) { if ( l == null ) return 0; return l.hd + sum (l.tl );} J.Carette (McMaster) CS 2S03 6 / 19

10 Disjunctive Data Types Disjoint union of types: Example: Arithmetic Expressions Syntax: ae ::= int var ae ae ae + ae J.Carette (McMaster) CS 2S03 7 / 19

11 Disjunctive Data Types Disjoint union of types: Example: Arithmetic Expressions Syntax: ae ::= int var ae ae ae + ae Type of expression: Expr = int String Expr Expr Expr + Expr J.Carette (McMaster) CS 2S03 7 / 19

12 Disjunctive Data Types Disjoint union of types: Example: Arithmetic Expressions Syntax: ae ::= int var ae ae ae + ae Type of expression: Expr = int String Expr Expr Expr + Expr Java Encloding (not great, we ll see better later) public enum Case { Const, Varm, Plus, Times } class Expr { Case select ; int val ; String var ; Expr arg1 ; Expr arg2 ;} J.Carette (McMaster) CS 2S03 7 / 19

13 Dynamic Data Types in Caml type list = {hd:int ; tl: list } The above does not work! (no null values only solutions are infinite!) J.Carette (McMaster) CS 2S03 8 / 19

14 Dynamic Data Types in Caml type list = {hd:int ; tl: list } The above does not work! (no null values only solutions are infinite!) The Solution: The disjoint union of a singleton - empty cartesian product - and of the cartesian product int list is defined below: type list = nil Cons of int * list J.Carette (McMaster) CS 2S03 8 / 19

15 Dynamic Data Types in C In C, the value of such an expression of a record type is the record itself there is no value null struct List { int hd; struct List tl ;}; is empty! J.Carette (McMaster) CS 2S03 9 / 19

16 Dynamic Data Types in C In C, the value of such an expression of a record type is the record itself there is no value null struct List { int hd; struct List tl ;}; is empty! What is implicit in Java must be explicitly stated in C: struct List { int hd; struct List * tl ;}; Specific syntax for a reference (pointer) there is a special reference called NULL which never points to valid memory. J.Carette (McMaster) CS 2S03 9 / 19

17 Dynamic Data Types in C - Cont. of the field tl can be either null, orareference.in, but there is a special reference called NULL that can mory and that plays the same role as null in Java. uct is not part of the fragment of the language that rtsingleton of the fragment List: that handles references, like the thereforeconstructthefollowingsingletonlist struct List l = {3, NULL }; L}; the state constructed in C is: structed in C is l 3 Remember in Java: l 95 3 list of two elements l J.Carette (McMaster) CS 2S03 10 / 19

18 x Garbage Collection 1 2 y = new List (3, new List (4, null )); y 3 4 hen you execute the statement y = null;, we associate the value null with y = null ; e reference r 4.Thememorystatenowbecomesm = [r 1 = r 2, r 2 = {hd = tl = r 3 }, r 3 = {hd = 2, tl = null}, r 4 = null, r 5 = {hd = 3, tl y r 6 }, r 6 = {hd = 4, tl = null}] garbage!' 3 4 The presence or the absence of these two cells in memory has no observable effect. Garbage Collectors take care of this! J.Carette (McMaster) CS 2S03 11 / 19

19 Programming with Lists Membership: x l? static boolean mem ( String x, List l) { if ( l == null ) return false ; if ( equal (x,l.hd )) return true ; return mem (x,l.tl );} J.Carette (McMaster) CS 2S03 12 / 19

20 Programming with Lists Membership: x l? static boolean mem ( String x, List l) { if ( l == null ) return false ; if ( equal (x,l.hd )) return true ; return mem (x,l.tl );} Alternatively: static boolean mem ( String x, List l) { while (l!= null ) { if ( equal (x,l.hd )) return true ; l = l.tl ;} return false ; } J.Carette (McMaster) CS 2S03 12 / 19

21 Programming with Lists - Cont. Concatenation: x 1,, x n, y 1,, y n Suppose List is a list of characters. Modify imperative static List append ( List x, List y) { if ( x == null ) return y; if ( y == null ) return x; // not needed, but nice! List t = x; // temporary while ( t. tl!= null ) t = t. tl; // walk to end t. tl = y; return x;} // why x? J.Carette (McMaster) CS 2S03 13 / 19

22 Programming with Lists - Cont. Modify - Cont.: Example List b = new List ( a,new List ( p,new List ( p, null ))); List c = new List ( e,new List ( n,new List ( d, null ))); x b p init$ a&er$while$loop$ Now,$Consider$ $$$$$$$$$$append(b,$b)$ $ Benefit:$no$alloca>on ~:$modify$arguments$$ a p p y a&er$t.tl$=$y;$ e n d c a&er$append(b,$b);$ J.Carette (McMaster) CS 2S03 14 / 19

23 Programming with Lists - Cont. Concatenation (Copy version) static List copy ( List x) { if ( x == null ) return x; List p = x; List q = new List (x.hd, null ); List r = q; while ( p. tl!= null ) { q.tl = new List (p.tl.hd, null ); q = q.tl;p = p.tl ;} return r;} static List copyappend ( List x, List y) { append ( copy (x),y); } Not efficient: traverses x in copy(x) J.Carette (McMaster) CS 2S03 15 / 19

24 Programming with Lists - Cont. Copy - Cont. How to do better? 1 inline code of copy into copyappend to get access to q [book does this] 2 get a hold of q! class Pair { public final List left ; public final List right ; public Pair ( List x, List y) { this. left =x; this. right =y; } } Change some lines of copy as follows: 1 st : static Pair copy (List x) last: return Pair(r, q); Now: copyappend { Pair p = copy (x); p. right.tl=y; return p. left ; } J.Carette (McMaster) CS 2S03 16 / 19

25 Programming with Lists - Cont. Concatenation:] Cont. Using Recursion static List append ( List x, List y) { if( x == null ) return y; return new List (x.hd, append (x.tl,y ));} J.Carette (McMaster) CS 2S03 17 / 19

26 Programming with Lists - Cont. List Inversion (extra arguments): x 1,, x n x n,, x 1 static List reverse ( final List x) { if ( x == null ) return null ; return add ( reverse (x.tl),x.hd );} static List add ( final List x, final int y) { if ( x == null ) return new List (y, null ); return new List (x.hd, add (x.tl,y ));} J.Carette (McMaster) CS 2S03 18 / 19

27 Programming with Lists - Cont. List Inversion (extra arguments): x 1,, x n x n,, x 1 static List reverse ( final List x) { if ( x == null ) return null ; return add ( reverse (x.tl),x.hd );} static List add ( final List x, final int y) { if ( x == null ) return new List (y, null ); return new List (x.hd, add (x.tl,y ));} The complexity: O(n 2 )!!! J.Carette (McMaster) CS 2S03 18 / 19

28 Programming with Lists - Cont. List Inversion (extra arguments): x 1,, x n x n,, x 1 static List reverse ( final List x) { if ( x == null ) return null ; return add ( reverse (x.tl),x.hd );} static List add ( final List x, final int y) { if ( x == null ) return new List (y, null ); return new List (x.hd, add (x.tl,y ));} The complexity: O(n 2 )!!! A linear time method is as follows: static List revappend ( final List x, final List y) { if ( x == null ) return y; return revappend (x.tl, new List (x.hd,y ));} static List reverse ( final List x) { return revappend (x, null );} J.Carette (McMaster) CS 2S03 18 / 19

29 Lists and Arrays Lists allow for simpler programs, but arrays allow for more efficient ones when the length is known. J.Carette (McMaster) CS 2S03 19 / 19

CS558 Programming Languages

CS558 Programming Languages Winter 2017 Lecture 7b Andrew Tolmach Portland State University 1994-2017 Values and Types We divide the universe of values according to types A type is a set of values and