1 / 24

Crash course on SML Wojciech Moczydłowski

Crash course on SML Wojciech Moczydłowski. SML – functional programming language Complete formal semantics Extremely convenient for writing compilers, interpreters, provers and 611 homeworks OCaml, based on SML, is practical and used in industry. SML - ideology.

shona
Download Presentation

Crash course on SML Wojciech Moczydłowski

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. Crash course on SMLWojciech Moczydłowski • SML – functional programming language • Complete formal semantics • Extremely convenient for writing compilers, interpreters, provers and 611 homeworks • OCaml, based on SML, is practical and used in industry

  2. SML - ideology • 3 worlds – expressions, values and types. • Values have types, i.e. 0 : int, “asd” : string • Expressions have types as well, i.e. 3+4 : int, fact : int -> int • Expressions evaluate to values

  3. SML types • Some types: • int, string, char • int*int, int*string • int -> int, int*int -> int • int -> int -> int • int list • ‘a list • ‘a -> ‘b -> ‘a

  4. Interpreter - 2+2; val it = 4 : int • 23+17; val it = 40 : int • “611 rules”; val it = “611 rules” : string - ~17 + 17; val it = 0 : int • (17, “a”); val it = (17, “a”) : int * string

  5. Definitions • val i = 10; val i = 10 : int • val j = i + i; val j = 20 : int • val s = Int.toString(j); val s = “20” : string • val t = (i, i + 1, i + 2); val t = (10, 11, 12) : int * int *int • val q = #2 t; val q = 11 : int

  6. Datatypes • datatype Bool = True | False • datatype Color = Red | Black • datatype Nat = Zero | S of Nat • True; val it = True : Bool • S(S(Zero)); val it = S(S(Zero)) : Nat

  7. Functions • fun add(n, m : Nat) : Nat = case n of Zero => m | S(x) => S(add(x, m)); • fun mult(n, m) = case n of Zero => Zero |S(x) => add(n, mult(x, m)) • Evaluation – call by value. • All functions have one argument – add : Nat * Nat -> Nat mult : Nat * Nat -> Nat

  8. Anonymous functions • As in lambda calculus, a function can be specified “on fly” • (fn x => x + 17) 26; val it = 43 : int; Large parts of lambda calculus can be expressed.

  9. Polymorphism • val K = fn x => fn y => x; val K = fn : ‘a -> ‘b -> ‘a ‘a ‘b are type variables. • K 6 4; val it = 6 : int • K “611” 170; val it = “611” : string • K K K;

  10. Polymorphism • val I = fn x => x; • val S = fn x => fn y => fn z => (x z) (y z); • val Ap = fn f => fn x => f x; However, the following won’t type-check: • val Y = fn f => (fn x => f (x x)) (fn x => f (x x)); • (fn x => x x) (fn x => x x);

  11. Datatypes reloaded • datatype ‘a option = NONE | SOME of ‘a; • NONE; val it = NONE : ‘a option; • SOME; val it = fn : ‘a -> ‘a option • SOME 5; val it = SOME 5 : int option; • SOME “Cornell”; val it = SOME “Cornell” : string option;

  12. Datatypes • fun div(m, n) = if n = 0 then NONE else SOME (m div n); • datatype (‘a, ‘b) Either = Left of ‘a | Right of ‘b;

  13. Recursive polymorphic datatypes • datatype ‘a Tree = Null | Node of (‘a Tree) * ‘a * (‘a Tree) • Node (Node(Null, 5, Null), 3, Null); • fun sum(t) = case t of Null => 0 | Node (a, b, c) => sum(a) + b + sum(c)

  14. RPD’s fun size(t) = case t of Null => 0 |Node(t1, _, t2) => size t1 + (size t2) + 1 fun add(t, n) = case t of Null => Null |Node(t1, m, t2) => Node(add(t1, n), m + n, add(t2, n))

  15. RPD’s fun mul(t, n) = case t of Null => Null |Node(t1, m, t2) => Node(mul(t1, n), m * n, mul(t2, n)) In general?

  16. RPD’s fun mapTree(t, f) = case t of Null => Null |Node(t1, m, t2) => Node(mapTree(t1, f), f m, mapTree(t2, f)) • fun add(t, n) = mapTree(t, fn m => m + n); • val mul = fn (t, n) => mapTree (t, fn m => n * m);

  17. RPD’s datatype ‘a list = nil | cons of (‘a * ‘a list); Notation: [] denotes nil (x::xs) denotes cons (x, xs)

  18. Lists Some lists: [] (1::(2::(3::nil))) (“a”::”b”::”c”::nil) Another notation: [a, b, c] = a::b::c::nil [1,2,3], [“a”, “b”, “c”]

  19. Lists • fun length(l) = case l of [] => 0 |(x::xs) => 1 + length xs; • fun hd [] = raise Fail “Empty” |hd(x::xs) = x; • fun tl [] = raise Fail “Empty” |tl (x::xs) = xs;

  20. Lists • fun map(f, l) = case l of [] => [] |(x::xs) => f x ::(map f xs);

  21. Modules signature SET = sig type ‘‘a set val empty : ‘‘a set val insert : ‘‘a -> ‘‘a set -> ‘‘a set val elem : ‘‘a -> ‘‘a set -> bool end

  22. Modules structure Set :> SET= struct type ’’a set = ‘‘a list val empty : ‘‘a set = [] val insert : ‘‘a -> ‘‘a set -> ‘‘a set = fn x => fn y => x::y val elem : ‘‘a -> ‘‘a set -> bool = ... end

  23. Accessing structure elements • Set.insert, Set.add .... • open Set; • insert, add, ...

  24. Standard library • Many useful structures • List :> LIST hd, tl, last, map, find, filter... • Option :> OPTION option, isSome, val Of, filter... • String :> STRING size, isSubstring, ^, <= ...

More Related