.

(Notes for 441 Lecture on 9/26/05.)

To Begin

• arizona or hats
• i could only get xserver working on hats
• add /u/cos441/ml to path in .cshrc
• run sml

Command Prompt

• read-eval-print loop
• val it = v:t

Types

• int

                 + - * div mod = < <= > >=

• real

                 + - * / 

• error: 3 + 4.2
• bool

                andalso orelse 

• string

                ^

• unit
• print: string -> unit

Expressions

• tuples
• type?
• records
• type?
• field order doesn't matter
• if e1 then e2 else e3
• type?
• value?
• why do we always need else clause?
• let d in e end
• type?
• value?
• not mutible -- shadowing
• case
• type --> show error
• value
• binding of variable, _
• parens on nested cases
• functions

Files

• command prompt
• use "foo.sml";
• emacs
• use .emacs given at ???
• open and buffer setup
• C-c C-b to send buffer

Datatypes

• encode options

                datatype nat = Zero | Succ of nat

• corresponds to rules from lecture
• create values using constructors

                val zero = Zero
                val two = Succ(Succ(Zero))

• distinguish options with case statement

                case two of Zero => print("zero") | Succ(_) => print("non-zero")   (* at command prompt *)

• make sure to capitalize Z or will always hit that case (as if it were a varaible
• function nat2int

                fun nat2int(n:nat):int =
                  case n of
                    Zero => 0
                  | Succ(x) => 1 + nat2int(x)


                fun int2nat(i:int):nat =
                  if (i = 0) then Zero
                    else Succ(int2nat(i-1))

• types optional
• add

                                                   |- add N1 N2 N3
                -------------------       ------------------------------
                |- add Z N N              |- add (S N1)  N2 (S N3)

                fun add(n1:nat,n2:nat):nat =
                  case n1 of
                    Zero => n2
                  | Succ(n1') => Succ(add(n1', n2))

                - add(int2nat 4, int2nat 8);
                val it = Succ (Succ (Succ (Succ (Succ #)))) : nat
                - nat2int(it);
                val it = 12 : int

Lists

• predefined

                datatype 'a list = nil | :: of 'a * 'a list

• 1 :: 2 :: nil : int list
• 'a can be any other type

                (true,3) :: (false,2) :: nil

• [1,2,3]
• can nest lists

                [[1,2],[3],[]] : int list list

• length

                fun length(l) =
                  case l of
                    nil => 0
                  | h::t => 1 + length(t)     (* type of h? t? *)

• append

                fun append(l1, l2) =
                   case l1 of
                     nil => l2
                   | h::t => h::append(t,l2)

• all the list functions are built in -- see SML Basis Library
• op@
• List.length;

Higher order functions

• functions can be passed as arguments and returned as parameters
• anonymous function

                val addone = fn x => x+1                (* addone: int -> int *)
                val addn = fn n => fn x => x + n        (* addn: int -> int -> int *)

• map: "modify" function to transform a list (preexists)
• take a function f and return a function to modify a list according to f
• what type do we want?

                map: ('a -> 'b) -> 'a list -> 'b list

• first pass

                fun map f =
                  fn l => case l of
                             nil => nil
                          | h::t => f(h) :: (map f t)

• syntactic sugar (curried function)

                fun map f l =
                  case l of
                    nil => nil
                  | h::t => f(h) :: (map f t)