Lecture 11: Standard ML

Simple examples

$ sml
Standard ML of New Jersey v110.67 [built: Thu Nov 15 10:18:08 2007]
- 1;
val it = 1 : int
- it;
val it = 1 : int
- it + 4;
val it = 5 : int
- fn x => x + 1;
val it = fn : int -> int
- fn x => x + x;
val it = fn : int -> int
- fn x => x + 1.0;
val it = fn : real -> real
- fn x : real => x + x;
val it = fn : real -> real
- it 1;
stdIn:1.1-4.2 Error: operator and operand don't agree [literal]
  operator domain: real
  operand:         int
  in expression:
    it 1

Recursion

- fun fact x = if x = 0 then 1 else x * fact (x-1);
val fact = fn : int -> int
- fact 3;
val it = 6 : int
- fact 0;
val it = 1 : int
- fact (~1);
  C-c C-c
Interrupt

Currying

- fn x => fn y => x + y;
val it = fn : int -> int -> int
- fn (x,y) => x + y;
val it = fn : int * int -> int

Mutual Recursion

- fun even x = if x = 0 then true else odd (x - 1)
= and odd x = if x = 0 then false else even (x - 1);
val even = fn : int -> bool
val odd = fn : int -> bool
- even 4;
val it = true : bool
- even 3;
val it = false : bool
- even 2;
val it = true : bool
- even 1;
val it = false : bool
- even 0;
val it = true : bool

Lists

- nil;
val it = [] : 'a list
- 2 :: nil;
val it = [2] : int list
- 1 :: 2 :: 3 :: nil;
val it = [1,2,3] : int list
- [1,2,3];
val it = [1,2,3] : int list
- val l = [1,2,3];
val l = [1,2,3] : int list
- 12 :: l;
val it = [12,1,2,3] : int list
- l;
val it = [1,2,3] : int list
- l @ l;
val it = [1,2,3,1,2,3] : int list
- [[1, 2], [3]];
val it = [[1,2],[3]] : int list list
- [1, [2, 3]];
stdIn:69.1-69.12 Error: operator and operand don't agree [literal]
  operator domain: int * int list
  operand:         int * int list list
  in expression:
    1 :: (2 :: 3 :: nil) :: nil
- hd l;
val it = 1 : int
- tl l;
val it = [2,3] : int list
- val empty : int list = [];
val empty = [] : int list
- hd empty;

uncaught exception Empty
  raised at: smlnj/init/pervasive.sml:194.19-194.24
- tl empty;

uncaught exception Empty
  raised at: smlnj/init/pervasive.sml:196.19-196.24

Pattern matching

- null;
val it = fn : 'a list -> bool
- null [];
val it = true : bool
- null [1,2];
val it = false : bool
- val null = fn l => (case l of nil => true | _ => false);
val null = fn : 'a list -> bool
- fun null l = case l of nil => true | _ => false;
val null = fn : 'a list -> bool
- fun null nil = true
=   | null _ = false;
val null = fn : 'a list -> bool

Polymorphism

- fun length nil = 0
=   | length (x :: l) = 1 + length l;
val length = fn : 'a list -> int
- length [1,2,3];
val it = 3 : int
- length [1.0, 2.0, 3.0];
val it = 3 : int
- length ["Hello", "There", "World"];
val it = 3 : int
- length [(fn x => x), (fn x => x + 1), (fn x => x * 2)];
val it = 3 : int

Higher-order functions

- fun addtolist (nil,n) = nil
=   | addtolist (x :: y, n) = (x + n :: addtolist(y,n));
val addtolist = fn : int list * int -> int list
- 
- fun multtolist (nil,n) = nil
=   | multtolist (x :: y, n) = (x * n :: multtolist(y,n));
val multtolist = fn : int list * int -> int list
- 
- addtolist ([1,2,3],2);
val it = [3,4,5] : int list
- addtolist ([1,2,3],3);
val it = [4,5,6] : int list
- multtolist ([1,2,3],3);
val it = [3,6,9] : int list
- 
- fun applytolist (nil,f) = nil
=   | applytolist (x :: y, f) = (f x :: applytolist(y,f));
val applytolist = fn : 'a list * ('a -> 'b) -> 'b list
- 
- map;
val it = fn : ('a -> 'b) -> 'a list -> 'b list
- map (fn x => x + 1) [1,2,3];
val it = [2,3,4] : int list
- map (fn s => "Hello " ^ s) ["Rob", "Karl", "Larry"];
val it = ["Hello Rob","Hello Karl","Hello Larry"] : string list

Products

- val x = (1,true);
val x = (1,true) : int * bool
- #1 x;
val it = 1 : int
- #2 x;
val it = true : bool
- case x of (a,b) => if b then a + 1 else a - 1;
val it = 2 : int
- 
- (1,true, "hello world", fn x => x);
val it = (1,true,"hello world",fn) : int * bool * string * ('a -> 'a)

Sums

- datatype mybool = True | False;
- fun my_not True = False
=   | my_not False = True;
val my_not = fn : mybool -> mybool
- fun my_and (True, True) = True
=   | my_and _ = False;
val my_and = fn : mybool * mybool -> mybool
- fun my_or (True,_) = True
=   | my_or (_,True) = True
=   | my_or _ = False;