9/23/2014. Function: it s easy and it is fun Local Function & Composite Function Polymorphic function I/O Structure and signature

Transcription

1 Dr A Sahu Dept of Computer Science & Engeerg IIT Guwahati Function: it s easy and it is fun Local Function & Composite Function Polymorphic function I/O Structure and signature Operator head hd and tail tl Head of list is an element and tail of a list is a list -val L=[,,3]; val L=[,,3]:t list -hd(l); val it=: t -tl(l); val it=[,3]: t list -tl(tl(tl(l))); val it=[]:t list Cons operator (: : ) take an element and a list and produce a list -::[3,4]; val it=[,3,4]:t list -.0::nil; val it=[.0]: real list -::::3::4; val it=[,,3,4]: t list Concatenation (@): concatenate two list of same type -[,]@[3,4]; val it=[,,3,4]: t list -fun reverse(l)= if L=nil then nil else reverse(tl(l))@ [hd(l)]; val reverse =fn: a list -> a list -reverse([,,3]; val it=[3,,]: a list -fun reverse(nil)=nil reverse(x::xs)=reverse(xs)@[x]; val reverse =fn: a list -> a list -fun split(nil)=nil split([a])=([a],nil); split(a::b::cs)= let val (M,N)=split(cs) (a::m,b::n) It divide the list to two equal parts with alternative element val split: fn : a list-> a list* a list -split([,,3,4,5]); val it=(,3,5],[,4]): t list * t list

2 - fun fst (x,y) = x; val fst = fn : 'a * 'b -> 'a - fst (,"two"); val it = : t - fun switch (x,y) = (y,x); val switch = fn : 'a * 'b -> 'b * 'a - switch (, "abc"); val it = ("abc",) : strg * t Op: convertg fix operators to function names -op + (,3); val it 5: t -fun map = map (f,nil) = nil map (f,h::t) = f(h) :: map (f,t); val map = fn : ('a->'b)*'a list -> 'b list -fun square(x:t)=x*x; val sqaure= fn:t->t -map(square,[,,3]); val it=[,4,9]; -map (fn x=>x+, [,,3,4,5]); val it = [,3,4,5,6] : t list -map(~,[,,3]); val it = [~,~,~3]: t list Defe function onle -fun comp(f,g)= let fun C(x)=G(F(x)) C val map = fn : ('a->'b)* ( b-> c)-> ('a-> c) -fun F(x)=x+3; val F=fn:t->t -fun G(y)=y*y+*y; val G = fn: t->t -val H=comp(F,G);; val H= fn:t->t -H(0); val it=95; - val f = comp (Math.s, Math.cos); val f = fn : real -> real - val g = Math.s o Math.cos; (* Composition "o" is predefed *) val g = fn : real -> real - f(0.5); val it = : real - g(0.5); val it = : real -fun map = map (f,nil) = nil map (f,h::t) = f(h) :: map (f,t); val map = fn : ('a->'b)*'a list -> 'b list -map(square,[,,3]); val it=[,4,9]; -fun reduce(f,nil) =raise EmptyList reduce(f,[a]) = a; reduce(f,x::xs)=f(x,reduce(f,xs); val reduce:fn: ( a* a-> a)* alist-> a -reduce(+,[,4,8]); val it=3:t -reduce(+,map(square,[,,3]); val it=3:t -fun plus(x:real)=x+y; val plus:fn :real*real->real n n Var = ( ai ) / n (( ai ) / n) i= i= -fun variance(l)= let val n=length(l) reduce(plus,map(sqaure(l))/n - square(reduce(plus,l)/n) val variance = fn: real list->real -variance ([.0,.0,5.0,8.0]); val it =7.5:real

3 -exception Factorial; -fun checked_factorial n = let fun fact 0 = fact n = n * fact (n-) if n > then fact n else raise Factorial val checked_factorial = fn : t -> t -fun factorial_driver () = let val put = read_teger () (* predefed*) val result = makestrg (checked_factorial put) prt result end handle Factorial => prt "Out of range.\n ; - datatype suit = Spades Hearts Diamonds Clubs datatype suit = Spades Hearts Diamonds Clubs -fun isspades(x) = (x=spades); val isspade = fn: fruit -> bool - datatype('a,'b) element = P of 'a*'b S of 'a; datatype ('a,'b) element = P of 'a * 'b S of 'a datatype ('a, b) element con P : a* b-> ( a, b) element con S : a-> ( a, b) element -fun(sumelist(nil)=0 ( sumelist(s(x)::l)=sumelist(l) sumelist(p(x,y)::l)=y+sumelist(l); val sumelist = fn : ('a *t) element list -> t -sumelist( [P(,6),S( function ),P( as,)]); val it = 8 : t - datatype 'a option = NONE SOME of 'a; datatype 'a option = NONE SOME of 'a fun expt (NONE, n) = expt (SOME, n) expt (SOME b, 0) = expt (SOME b, n) = b * expt (SOME b, n-); val expt = fn : t option * t -> t -expt(some 3,); val it =9 ;t; -expt(none,4); val it =6 ;t; - datatype 'a tree = Empty Node of 'a tree * 'a * 'a tree ; datatype 'a tree = Empty Node of 'a tree * 'a * 'a tree -fun height Empty = 0 height(node(lft,_,rht)) =+Int.max(height lft,height rht); val height = fn : 'a tree -> t -fun size Empty = 0 size(node(lft,_,rht))=+size lft +size rht ; Val size = fn : 'a tree -> t - Val t=node(node(empty,,empty),,node(empty,3,empty)); val t = Node (Node (Empty,,Empty),,Node (Empty,3,Empty)) : t tree - height(t); val it = : t - fun preorder(empty) = nil preorder (Node(lft,a,rht))= preorder preorder (rht) ; Val size = fn : 'a tree -> a list Val t=node(node(empty,,empty),,node(empty,3,empty)); val t = Node (Node (Empty,,Empty),,Node, p y),, (Empty,3,Empty)) : t tree - preorder(t); val it = [,,3] : t list 3

4 - datatype 'a tree = Node of 'a * 'a tree list; val size = fn : 'a tree -> a list -val t=node(3,[ Node (4,nil), Node(5, [Node(7,nil)]), Node(6,nil)]); val it = Node (3,[Node (#,#),Node (#,#),Node (#,#)]) : t tree -fun Sum(Node(a:t,nil))=a Sum (Node(a,t::ts)) = Sum(t) +Sum(Node(a,ts)); val Sum = fn : t tree -> list - Sum (t); val it = 5: t -datatype expr = Numeral of t Plus of expr * expr Times of expr * expr; datatype expr = Numeral of t Plus of expr * expr Times of expr * expr -fun eval (Numeral n) = Numeral n eval (Plus (e, e)) = let val Numeral n = eval e; val Numeral n = eval e Numeral (n+n) end eval (Times (e, e)) = let val Numeral n = eval e; val Numeral n = eval e Numeral (n*n) val eval = fn : expr -> expr -structure Complex = struct type t = real*real; val zero = (0.0, 0.0); fun sum ((x,y), (x',y')) = (x+x', y+y') : t; fun diff ((x,y), (x',y')) = (x-x', y-y') y : t; fun prod ((x,y), (x',y')) = (x*x' - y*y', x*y' + x'*y) : t; fun recip (x,y) = let val t:real = x*x + y*y (x/t, ~y/t) end fun quo (z,z') = prod(z, recip z'); -structure Complex = struct type t = real*real; val zero = (0.0, 0.0); fun sum ((x,y), (x',y')) = (x+x', y+y') : t; fun diff ((x,y), (x',y')) = (x-x', y-y') : t; fun prod ((x,y), (x',y')) ')) = (x*x' - y*y', x*y' + x'*y) : t; fun recip (x,y) = let val t:real = x*x + y*y (x/t, ~y/t) end fun quo (z,z') = prod(z, recip z'); -signature ARITH = sig type t val zero : t val sum : t * t -> t val diff : t * t -> t val prod : t * t -> t val quo : t * t -> t - complex.add( (.0,.0),(3.0,4.0)); val it = (4.0,6.0) : complex -open Real; -open Int; -open Strg; -open List; -open Array; -open Queue; -open Math; 4

5 -val Graph=[( a, b ), ( a, d ),..]; (*membership a list*) fix mem; fun x mem [] = false x mem (y::tl) = (x=y) orelse (x mem tl); (* fd neighbours *) fun nexts (a, []) = [] nexts (a, (x,y)::pairs) = if a=x then y :: nexts(a,pairs) else nexts(a,pairs); -fun depthf ([], graph, visited) = rev visited depthf (x::xs, graph, visited) = if x mem visited then depthf (xs, graph, visited) else depthf xs, graph, x::visited); -depthf([ a ], graph, []); 5