More eamples with half half(0) handle Zero => 1000; > val it = 1000 : int half(1) handle Zero => 1000; > ncaght eception Odd half(0) handle Zero => 10

Transcription

1 Lectre 4 0

2 More eamples with half half(0) handle Zero => 1000; > val it = 1000 : int half(1) handle Zero => 1000; > ncaght eception Odd half(0) handle Zero => 1000 Odd => 1001; > val it = 1000 : int half(3) handle Zero => 1000 Odd => 1001; > val it = 1001 : int Instead of Zero and Odd cold have a single kind of eception containing a string eception Half of string; > eception Half fn half n = if n=0 then raise Half "Zero" else let val m = n div 2 in if n=2*m then m else raise Half "Odd" end; > val half = fn : int -> int 1

3 Yet more eamples with half Contents of eception packets not printed half 0; > ncaght eception Half half 3; > ncaght eception Half half(0) handle Half "Zero" => 1000 Half "Odd" => 1001; > val it = 1000 : int half(3) handle Half "Zero" => 1000 Half "Odd" => 1001; > val it = 1001 : int Cold match contents of eception packet to a variable, s say, and then branch on the vale matched to s half(0) handle Half s => (if s="zero" then 1000 else 1001); > val it = 1000 : int half(3) handle Half s => (if s="zero" then 1000 else 1001); > val it = 1001 : int 2

4 Datatype declarations New types can also be dened Datatypes are dened by a set of constrctors which can be sed to create objects of that type and also { via patterns { to decompose objects datatype card = king qeen jack other of int; > datatype card > con jack : card > con king : card > con other : int -> card > con qeen : card Declares constrctors king, qeen, jack, other Gives constrctors vales vale of a 0-ary constrctors is constant vale vale of 1-ary constrctor other is a fnction given an integer vale n prodces other(n) king; > val it = king : card other(4+5); > val it = other 9 : card 3

5 Patterns and constrctors Constrctors can be sed in pattern matching fn vale king = 500 vale qeen = 200 vale jack = 100 vale (other n) = 5*n; > val vale = fn : card -> int Or: val vale = fn king => 500 qeen => 200 jack => 100 (other n) => 5*n; > val vale = fn : card -> int 4

6 Primitive datatypes The booleans cold be dened by: datatype bool = tre false; > datatype bool > con false : bool > con tre : bool The positive integers datatype int = zero sc of int; > datatype int > con sc : int -> int > con zero : int 5

7 Lisp S-epressions datatype sep = litatom of string nmatom of int cons of sep * sep; > datatype sep > con cons : sep * sep -> sep > con litatom : string -> sep > con nmatom : int -> sep fn car (cons(,y)) = and cdr (cons(,y)) = y; > Warning: match nonehastive > val car = fn : sep -> sep > Warning: match nonehastive > val cdr = fn : sep -> sep val a1 = litatom "Foo" and a2 = nmatom 1; > val a1 = litatom "Foo" : sep > val a2 = nmatom 1 : sep car(cons(a1,a2)); > val it = litatom "Foo" : sep cdr(cons(a1,a2)); > val it = nmatom 1 : sep These fntions are only partially specied car (litatom "foo"); > ncaght eception Match 6

8 Abstract types An abstract type declaration has the form abstype d with b end d is a datatype specication b is a binding i.e. the kind of phrase that can follow val Sch a declaration introdces: a new type, ty say specied by the datatype declaration d Constrctors declared on ty by d only available within b Eported bindings are those specied in b Vales of an abstract type are printed as \-" 7

9 Eample abstract type eception BadTime; > eception BadTime abstype time = time of int * int with fn maketime(hrs,mins) = if hrs<0 orelse 23<hrs orelse mins<0 orelse 59<mins then raise BadTime else time(hrs,mins) and hors(time(t1,t2)) = t1 and mintes(time(t1,t2)) = t2 end; > type time > val maketime = fn : int * int -> time > val hors = fn : time -> int > val mintes = fn : time -> int val t = maketime(8,30); > val t = - : time (hors t, mintes t); > val it = (8,30) : int * int Denes an abstract type time with three primitive fnctions: maketime, hors, mintes 8

10 abstype { smmary An abstract type declaration simltaneosly declares a new type together with primitive fnctions for the type The representation datatype is not accessible otside the with-part of the declaration 9

11 Type constrctors list and * are type constrctors list has one argment { hence 'a list * has two { hence 'a * 'b Usefl operations can be dened sing patterns fn fst(,y) = and snd(,y) = y; > val fst = fn : 'a * 'b -> 'a > val snd = fn : 'a * 'b -> 'b val p = (8,30); > val p = (8,30) : int * int fst p; > val it = 8 : int snd p; > val it = 30 : int See also previos denitions of hd, tl, nll 10

12 Eample: sets set represents sets as lists withot repetitions abstype 'a set = set of 'a list with val emptyset = set[] fn isempty(set s) = nll s fn member(_, set[]) = false member(, set(y::z)) = (=y) orelse member(, set z) fn add(, set[]) = set[] add(, set(y::z)) = if =y then set(y::z) else let val set l = add(, set z) in set(y::l) end end > val emptyset = [] : 'a list > val isempty = fn : 'a set -> bool > val member = fn : ''a * ''a set -> bool > val add = fn : ''a * ''a set -> ''a set val s = add(1,(add(2,(add(3,emptyset))))); > val s = - : int set member(3,s); > val it = tre : bool member(5,s); > val it = false : bool 11

13 References and assignment References are `boes' that can contain vales Contents can be changed sing := \ty ref" is type of references containing vales of type ty References are created sing the ref operator takes a vale of type ty to a vale of type ty ref. :=e changes contents of reference to the vale of e Vale of assignment epression is () assignments are eected for a `side eect', not for their vale Contents of a reference can be etracted sing the! operator 12

14 Eample showing references val = 0; :=1; > Type clash in: ( := 1) > Looking for a: 'a ref > I have fond a: int val = ref 1 and y = ref 2; > val = ref 1 : int ref > val y = ref 2 : int ref ; > val it = ref 1 : int ref :=6; > val it = () : nit ; > val it = ref 6 : int ref!; > val it = 6 : int Only se references if yo have to! eperience shows their se increases errors 13

15 Iteration Semicolon denotes seqencing vale of e 1;: : :;en is vale of en Evalating while e do c consists in evalating e if the reslt is tre c is evalated for its side-eect and then the whole process repeats if e evalates to false the evalation of while e do c terminates with vale () 14

16 Eample: iterative factorial An iterative denition of fact ses two local references: cont and reslt fn fact n = let val cont = ref n and reslt = ref 1 in while!cont > 0 do (reslt :=!cont *!reslt; cont :=!cont-1);!reslt end; > val fact = fn : int -> int fact 6; > val it = 720 : int 15