1 / 56

Introduction to ML

Introduction to ML. CS 331 Principles of Programming Languages revised Spring 2003. Features of ML. A pure functional language serious programs can be written without using variables Widely accepted reasonable performance (claimed) can be compiled

etoile
Download Presentation

Introduction to ML

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Introduction to ML CS 331 Principles of Programming Languages revised Spring 2003

  2. Features of ML • A pure functional language • serious programs can be written without using variables • Widely accepted • reasonable performance (claimed) • can be compiled • syntax not as arcane (or as simple) as LISP

  3. In these slides, • We use Standard ML of New Jersey • Runs on PCs, Linux, and other flavors of UNIX • Much of this material is based on Ullman’s book, Elements of ML Programming • See the SML documentation athttp://www.smlnj.org

  4. Running SML on linix.gl • The SML processor is available at/afs/umbc.edu/users/n/i/nicholas/pub/331/smlnj.linux/binor equivalently~nicholas/../pub/331/smlnj.linux/bin • Add this directory to your path, and do a rehash • Then invoke sml from a shell prompt with the command sml • Use control d to exit interpreter

  5. Hello, world in SML Standard ML of New Jersey, - print("Hello world\n"); Hello world val it = () : unit -

  6. Arithmetic in ML • Copy and paste the following text into a Standard ML window 2+2; (* note semicolon at end*) 3*4; 4/3; (* an error! *) 6 div 2; (* integer division *) 7 div 3;

  7. Declaring Constants • Constants are not exactly the same as variables • they can be redefined, but existing uses of that constant (e.g. in function definitions) aren’t affected by such redefinition val freezingFahr = 32;

  8. Ints and Reals • Note ~ is unary minus • min and max take just two input arguments, but that can be fixed! • The real operator converts to real • Parens can sometimes be omitted, but I don’t recommend it Int.abs ~3; Int.sign ~3; Int.max (4, 7); Int.min (~2, 2); real(freezingFahr); Math.sqrt real(2); Math.sqrt(real(2)); Math.sqrt(real 3);

  9. - Int.abs ~3; val it = 3 : int - Int.sign ~3; val it = ~1 : int - Int.max (4, 7); val it = 7 : int - Int.min (~2, 2); val it = ~2 : int - Math.sqrt real(2); stdIn:57.1-57.18 Error: operator and operand don't agree [tycon mismatch] operator domain: real operand: int -> real in expression: Math.sqrt real - Math.sqrt(real(2)); val it = 1.41421356237 : real - Math.sqrt(real 3); val it = 1.73205080757 : real

  10. Strings • Delimited by double quotes • the caret mark ^ is used for string concatenation, e.g. “house”^”cat” • \n is used for newline, as in C and C++

  11. Comparison Operators • The usual <, >, <=, >= and <> are available • For reals, = and <> are not available • For reals a and b, a <= b andalso a>= b is an equality test • The connectors “andalso” and “orelse” are logical operators with short-circuit evaluation

  12. If Then Else • If Then Else is an expression, not a control structure • Example, if quotient, dividend and divisor are reals, we might haveval quotient = if divisor > 0 then dividend/divisor else 0

  13. Tuples • Tuples are data items drawn from a Cartesian product type. Example:type fraction = int * int;val foo: fraction = (44,100);#1(foo); (* returns 44 *)#2(foo); (* returns 100 *) • Tuples are of fixed size, e.g. 2 in this example

  14. Lists in ML • Objects in a list must be of the same type • [1,2,3]; • [“dog”, “cat”, “moose”]; • The empty list is written [] or nil

  15. Making Lists • The @ operator is used to concatenate two lists of the same type • The :: operator makes a new list in which its first operand is the new first element of a list which is otherwise like the second operand. • The functions hd and tl give the first element of the list, and the rest of the list, respectively

  16. List Operations - val list1 = [1,2,3]; val list1 = [1,2,3] : int list - val list2 = [3,4,5]; val list2 = [3,4,5] : int list - list1@list2; val it = [1,2,3,3,4,5] : int list - hd list1; val it = 1 : int - tl list2; val it = [4,5] : int list

  17. More List Operations - val list1 = [1,2,3]; val list1 = [1,2,3] : int list - val list2 = [3,4,5]; val list2 = [3,4,5] : int list - 4::list1; val it = [4,1,2,3] : int list - val list3 = list1::list2; an error! - val list3=list1@list2; val list3 = [1,2,3,3,4,5] : int list - length(list3); val length(list3) = 6

  18. Strings and Lists • The explode function converts a string into a list of characters • The implode function converts a list of characters into a string • Examples: - explode("foo"); val it = [#"f",#"o",#"o"] : char list - implode [#"c",#"a",#"t"]; val it = "cat" : string -

  19. Heads and Tails • The cons operator :: takes an element and prepends it to a list of that same type. • For example, the expression 1::[2,3] results in the list [1,2,3] • What’s the value of [1,2]::[ [3,4], [5,6]] ? • What’s the value of x::[], for any atom x?

  20. Declaring Functions • A function takes an input value and returns an output value • ML will figure out the types

  21. Notes • ML is picky about not mixing types, such as int and real, in expressions • The value of “it” is always the last value computed • Function arguments don’t always need parentheses, but it doesn’t hurt to use them

  22. Types of arguments and results • ML figures out the input and/or output types for simple expressions, constant declarations, and function declarations • If the default isn’t what you want, you can specify the input and output types, e.g. fun divBy2 x:int = x div 2 : int; fun divideBy2 (y : real) = y / 2.0; divBy2 (5); divideBy2 (5.0);

  23. Two similar divide functions - fun divBy2 x:int = x div 2 : int; val divBy2 = fn : int -> int - fun divideBy2 (y : real) = y / 2.0; val divideBy2 = fn : real -> real - divBy2 (5); val it = 2 : int - divideBy2 (5.0); val it = 2.5 : real -

  24. Functions and Patterns • Recall that min and max take just two arguments • However, using the fact that, for example, • min(a, b, c) = min(a, min(b, c))

  25. Generalizing Min • An example of ML pattern matching • the cons notation x::xs is both a binary constructor and a pattern • cases aren’t supposed to overlap • Note that lists of any size are supported • but the elements are expected to be integers • checking that the rest of the list is non-empty is critical - but why?

  26. (* Sample ML program - MinList *) (* Takes a list of integers as input, and returns a list with at most one element, i.e. the smallest element in the list *) fun MinList([]) = [] | MinList(x::xs) = if null(xs) then [x] else [Int.min(x,hd(MinList(xs)))]; MinList([]); MinList([1,2]); MinList([315, 41, 59, 265, 35, 897]);

  27. When we run MinList,… - use "MinList.sml"; [opening MinList.sml] val MinList = fn : int list -> int list val it = [] : int list val it = [1] : int list val it = [35] : int list val it = () : unit

  28. Building trees • It’s easy to build recursive data types in ML • Some examples follow

  29. (* Sample ML program - Abstract Syntax Trees *) (* Declare the ast datatype *) datatype ast = empty | leaf of int | node of string*ast*ast; fun traverse(empty) = print "empty tree" | traverse(leaf(n)) = (print (Int.toString(n)); print " ") | traverse(node(operator, left, right)) = ( traverse(left); print operator; traverse(right)); fun prefix(tree:ast) = (traverse(tree); print "\n"); prefix(empty); prefix(leaf(4)); prefix(node("*",node("+",leaf(5),leaf(3)),node("-",leaf(10),leaf(4))));

  30. Two ways to count (* count from i to j *) fun countUp(i:int, j:int) = if i=j then print(" "^Int.toString(j)) else (countUp(i,j-1);print(" "^Int.toString(j))); (* count from i to j *) fun TcountUp(i:int, j:int) = if i=j then print(" "^Int.toString(j)^"\n") else (print(" "^Int.toString(i));TcountUp(i+1,j));

  31. What about control structures? • Well, there aren’t any in the usual (procedural) sense • If then else, case, and iteration are all accomplished by evaluation of expressions

  32. Iteration vs. Recursion (* note that F is a functional parameter *) fun loopIt(i:int,n:int,F) = if i = n then F(i) else let val dummy = F(i) val dummy2 = loopIt(i+1,n,F) in dummy2 (* any expression could be used *) end;

  33. The Print Function • print(“This string\n”); • print(“2+2 is “^Int.toString(2+2)^”\n”); • Expressions may be grouped with parentheses, e.g (print(“a”);print(“b”)) • But the grouped expressions may not change the environment, so this is not the same as a block in a procedural language

  34. More About I/O • To access functions in the TextIO structure, open TextIO; • To open a file openIn(“somefile”); • The value returned is of type instream • endOfStream(file:instream): bool • inputN(file:instream,n:int):string • input(file:stream):string (* whole file *)

  35. Matches and Functions • Example of match expression:val rec reverse = fn nil => nil| x::xs => reverse(xs) @ [x]; • The rec keyword stands for “recursive”, which is necessary because the binding of reverse as a function name is not yet established

  36. Anonymous Functions • Functions don’t have to have names, e.g.(fn x => x+1) (3) yields 4 • Such functions can be passed as parameters, e.g. for use in the map or reduce functions, to be discussed later in this chapter.

  37. If Then Else = Case • The familiar if E1 then E2 else E3is equivalent tocase E1 of true => E2 | false => E3 • Example: if x<y then #”a” else #“b”is the same ascase x<y of true => #”a” | false => #“b” (* note same types *)

  38. Exceptions • exception Foo and Bar; • raise Foo; • exception Foo of string; • The handle clause matches exceptions with (hopefully) suitable actions • Exceptions can be defined in let clauses

  39. Polymorphic Functions • If you don’t know the type in advance, or if it doesn’t matter,‘a list matches a list of any type • Example:fun listLen(x: ‘a list) = if x = nil then 0 else 1+listLen(tl(x));

  40. Higher Order Functions • Functions may be passed as parameters,e.g.fun trap(a,b,n,F)= if n <= 0 orelse b-a <= 0.0 then 0.0 else let val delta = (b-a)/real(n) in delta*(F(a)+F(a+delta))/2.0+ trap(a+delta,b,n-1,F) end;

  41. Higher-Order Function map • The map function map(F,[a1,a2,…,an]) produces the list [F(a1),F(a2),…,F(an)] • The function may be defined (per Harper’s new ML book)fun map f nil = nil| map f (h::t) = (f h)::(map f t)

  42. Higher-Order Function reduce • The reduce function reduce(F,[a1,a2,…,an]) produces F(a1,F(a2,F(…,F(an-1, an)…))) • The reduce function may be implemented as follows (from Ullman)exception EmptyList;fun reduce (F, nil) = raise EmptyList| reduce (F, [a]) = a | reduce (F, x::xs) = F(x, reduce(F,xs));

  43. More on reduce • Harper gives a more general form of reducefun reduce (unit, opn, nil) = unit | reduce (unit, opn, h::t) = opn(h, reduce (unit, opn, t)) • Example: two ways to sum a list of numbersfun add_up nil = 0| add_up(h::t) = h + add_up torfun add_up alist = reduce (0, op +, alist) • The op keyword allows + to be a parameter

  44. More on reduce • To avoid passing unit and opn as parameters that don’t change, again from Harper’s book,fun better_reduce (unit, opn, alist) = let fun red nil = unit | red (h::t) = opn(h, red t)) in red alist end • We have less overhead by passing only those parameters that change

  45. More on reduce • “Staging” helps even more! Again from Harperfun staged_reduce (unit, opn) = let fun red nil = unit | red (h::t) = opn(h, red t)) in red end • We can use staged_reduce on many lists, e.g.reduce(unit, opn, alist)is the same as (but slower than)staged_reduce(unit, opn) alist

  46. Higher-Order Function filter • The filter function takes a predicate P and a list [a1,a2,…,an] and returns the sublist such that P is true for every element of the sublist • To implement filterfun filter(P, nil) = nil| filter(P, x::xs) = if P x then x::filter(P,xs) else filter(P,xs)

  47. The ML Type System • Basic types include int, real, string, char, bool, and others • Tuple types, e.g. int*real*char • Function types, e.g. int->bool • Type constructors list and option • int list • char option

  48. Creating Names for Types • type orderpair = int*int • type finiteSequence = real list; • and these can be parameterized

  49. Datatypes • Enumerated types, e.g. datatype berryType = raspberry | blueberry | blackberry; • So then we can say, for example, val b:berryType = raspberry;

  50. Recursive Datatypes • Example: binary trees, where the values may be of some type ‘label: datatype ‘label btree = Empty |Node of ‘label * ‘label btree * ‘label btree • val inBinary: int btree = Node(5,Node(1,Empty,Empty),Empty)

More Related