Reasoning about type inference

	(*
	f: T1 -> T2 [must be a function; all functions take 1 arg]
	x: T1
	y: T3
	z: T4
	T1 = T3 * T4 [else pattern match does not type-check]
	T3 = int [abs has type int -> int]
	T4 = int [because we added z to an int]
	So T1 = int * int
	So (abs y) + z: int, so let-expression: int, so body: int
	T2 = int
	f: int * int -> int
	*)
	fun f x =
	let val (y,z) = x in
	(abs y) + z
	end

view raw gistfile1.sml hosted with ❤ by GitHub

	(*
	sum: T1 -> T2
	xs: T1
	x: T3
	xs': T3 list [pattern match a T1]
	T1 = T3 list
	T2 = int [because 0 might be returned]
	T3 = int [because x:T3 and we add x to something]
	from T3 = int, we know T1 = int list
	from that and T2=int, we know f: int list -> int
	*)
	fun sum xs =
	case xs of
	[] => 0
	| x::xs' => x + (sum xs')

view raw gistfile1.sml hosted with ❤ by GitHub

	(*
	length: T1 -> T2
	xs: T1
	x: T3
	xs': T3 list
	T1 = T3 list
	T2 = int
	There are no more constraints, therefore
	T3 list -> int
	'a list -> int
	*)
	fun length xs =
	case xs of
	[] => 0
	| x::xs' => 1 + (length xs')

view raw gistfile1.sml hosted with ❤ by GitHub

	(*
	f: T1 * T2 * T3 -> T4
	x: T1
	y: T2
	z: T3
	T4 = T1 * T2 * T3
	T4 = T2 * T1 * T3
	only way those can both be true is if T1 = T2
	put it all together: f: T1 * T1 * T3 -> T1 * T1 * T3
	'a * 'a * 'b -> 'a * 'a * 'b
	*)
	fun f (x,y,z) =
	if true
	then (x,y,z)
	else (y,x,z)

view raw gistfile1.sml hosted with ❤ by GitHub

	(*
	compose: T1 * T2 -> T3
	f: T1
	g: T2
	x: T4
	body being a functoin has type T3 = T4 -> T5
	from g being passed x, T2 = T4 -> T6 for some T6
	from f being passed the result of g, T1 = T6 -> T7 for some T7
	from call to f being the body of anonmymous function T7 = T5
	put it all together: T1 = T6 -> T5, T2 = T4 -> T6, T3 = T4 -> T5
	(T6 -> T5) * (T4 -> T6) -> (T4 -> T5)
	('a -> 'b) * ('c -> 'a) -> ('c -> 'b)
	*)
	fun compose (f,g) = fn x => f (g x)

view raw gistfile1.sml hosted with ❤ by GitHub

Closure idioms without closures (ML version)

	datatype 'a mylist = Cons of 'a * ('a mylist) | Empty
	fun map f xs =
	case xs of
	Empty => Empty
	| Cons(x,xs) => Cons(f x, map f xs)
	fun filter f xs =
	case xs of
	Empty => Empty
	| Cons(x,xs) => if f x then Cons(x.filter f xs) else filter f xs
	fun lenght xs =
	case xs of
	Empty => 0
	| Cons(_,xs) => 1 + length xs
	(* a valid way to double all numbers in the list
	using partial application *)
	val doubleAll = map (fn x => x * 2)
	(* a way to count N's in a list using partial application *)
	val countNs (xs, n:int) = length (filter (fn x => x=n) xs)

view raw gistfile1.sml hosted with ❤ by GitHub

Mixing closures with abstract datatypes

	(* abstract data types with closures *)
	datatype set = S of { insert : int -> set,
	member : int -> bool,
	size : unit -> int }
	val empty_set =
	let
	fun make_set xs = (* xs is a private field in result *)
	let
	fun contains i = List.exists (fn j => i=j) xs
	in
	S { insert = fn i => if contains i
	then make_set xs
	else make_set (i::xs),
	member = contains,
	size = fn () => length xs
	}
	end
	in
	make_set []
	end
	(* example of using our newly described set *)
	fun use_sets() =
	let val S s1 = empty_set
	val S s2 = (#insert s1) 34
	val S s3 = (#insert s2) 34
	val S s4 = #insert s3 19
	in
	if (#member s4) 42
	then 99
	else if (#member s4) 19
	then 17 + (#size s3) ()
	else 0
	end

view raw gistfile1.sml hosted with ❤ by GitHub

Callbacks using mutable references (ML)

	val cbs: (int -> unit) list ref = ref []
	(*
	x = ref 4 means x has a reference to a value of type int with initial value 4
	x := 5 means update the value x refers to with value 5
	val y = (!x) means store the value x refers to in y
	*)
	fun onKeyEvent f = cbs := f :: (!cbs)
	fun onEvent i =
	let fun loop fs =
	case fs of
	[] => ()
	|f::fs' => (f i; loop fs')
	in loop (!cbs) end
	(* some client code *)
	val timesPressed = ref 0
	val _ = onKeyEvent (fn _ => timesPressed := (!timesPressed) + 1
	fun printIfPressed i =
	onKeyEvent (fn j =>
	if i=j
	then print ("you pressed " ^ Int.ToString i)
	else ()

view raw gistfile1.sml hosted with ❤ by GitHub

Currying (ML)

	(* old way to get the effect of multiple arguments *)
	fun sorted3_tupled (x,y,z) = z >= y andalso y >= x
	val t1 = sorted3_tupled (7,9,11)
	(* new way using currying *)
	val sorted3 = fn x => fn y => fn z => z >= y andalso y >= x
	val t2 = ((sorted3 7) 9) 11
	(* we can curry using syntactic sugar *)
	val t3 = sorted3 7 9 11
	(* declare a curried function by using spaces between multi arguments *)
	fun sorted3_nicer x y z = z >= y andalso y >= x
	(* now we can write a fold function using currying *)
	fun fold f acc xs = (* means fun fold f = fn acc => fn xs => *)
	case xs of
	[] => acc
	|x:xs' => fold f (f(acc,x)) xs'
	fun sum xs = fold (fn (x,y) => x + y) 0 xs

view raw gistfile1.sml hosted with ❤ by GitHub

Function composition (ML)

	(* 'b -> 'c) * ('a -> b') -> ('a -> 'c) *)
	fun compose(f,g) = fn x => f(g x)
	(* in ML you can compose functions like f o g *)
	fun sqrt_of_abs1 i = Math.sqrt (Real.fromInt (abs i))
	val sqrt_of_abs2 = Math.sqrt o Real.fromInt o abs
	(* we can also define our own infix operator to compose functions
	the other way around *)
	infix !>
	fun x !> f = f x
	fun sqrt_of_abs3 i = i !> abs !> Real.fromInt !> Math.sqrt
	fun backup1 (f,g) = fn x => case f x of
	NONE => g x
	| SOME => y

view raw gistfile1.sml hosted with ❤ by GitHub

A few examples of how lexical scope works (ML)

A function body is evaluated in the environment where the function was defined (created).

	val x = 1
	fun f y =
	let
	val x = y + 1
	in
	fn z => x + y + z (* will return 2y + 1 + z *)
	end
	val x = 3 (* irrelevant *)
	val g = f 4 (* return a function that ads 9 to its argument *)
	val y = 5 (* irrelevant *)
	val z = g 6 (* get 15 *)
	(* output of program
	- use "lexical1.sml";
	[opening lexical1.sml]
	val x = <hidden-value> : int
	val f = fn : int -> int -> int
	val x = 3 : int
	val g = fn : int -> int
	val y = 5 : int
	val z = 15 : int
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

	fun f g =
	let
	val x = 3 (* irrelevant *)
	in
	g 2
	end
	val x = 4
	fun h y = x + y (* add 4 to its argument *)
	val z = f h (* get 6 *)
	(* output of program
	- use "lexical2.sml";
	[opening lexical2.sml]
	val f = fn : (int -> 'a) -> 'a
	val x = 4 : int
	val h = fn : int -> int
	val z = 6 : int
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Higher order functions Map and Filter (ML)

	(* ('a -> 'b) * 'a list -> 'b list *)
	fun map(f,xs) =
	case xs of
	[] => []
	| x::xs' => (f x)::map(f,xs')
	val x1 = map((fn x => x + 1), [4,8,12,16])
	val x2 = map(hd, [ [1,2], [3,4], [5,6,7] ])
	(* ('a -> bool) * 'a list -> 'a list *)
	fun filter(f,xs) =
	case xs of
	[] => []
	| x::xs' => if f x
	then x::(filter (f, xs'))
	else filter(f,xs')
	fun is_even v =
	(v mod 2 = 0)
	fun filter_even xs = filter(is_even, xs)
	val x3 = filter_even([1,2,3,4,5,6])
	(* output of program
	- use "mapfilter.sml";
	[opening mapfilter.sml]
	val map = fn : ('a -> 'b) * 'a list -> 'b list
	val x1 = [5,9,13,17] : int list
	val x2 = [1,3,5] : int list
	val filter = fn : ('a -> bool) * 'a list -> 'a list
	val is_even = fn : int -> bool
	val filter_even = fn : int list -> int list
	val x3 = [2,4,6] : int list
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Using higher order and anonymous functions in ML

	fun increment_n_times (n,x) = (* computes n + x *)
	if n=0
	then x
	else 1 + increment_n_times(n-1,x)
	fun double_n_times (n,x) = (* computes 2^n * x *)
	if n=0
	then x
	else 2 * double_n_times(n-1,x)
	fun nth_tail (n,xs) = (* example 3,[4,8,12,16] -> [16] *)
	if n=0
	then xs
	else tl (nth_tail(n-1,xs))
	(* n_times is a higher-order function which takes a function, an int and a value and
	it's signature is ('a -> 'a) * int * 'a -> 'a
	*)
	fun n_times (f,n,x) =
	if n=0
	then x
	else f (n_times(f, n-1,x))
	fun increment x = x +1
	fun double x = x + x
	val x1 = n_times(double,4,7)
	val x2 = n_times(increment,4,7)
	val x3 = n_times(tl, 2, [4,8,12,16])
	fun addition (n,x) = n_times(increment, n, x)
	fun double_n_times (n,x) = n_times(double,n,x)
	fun nth_tail(n,xs) = n_times(tl, n, xs)
	(* example of using an anonymous function *)
	fun triple_n_times (n,x) = n_times((fn x => 3 *x),n,x)
	(* output of program
	- use "higherorder.sml";
	[opening higherorder.sml]
	val increment_n_times = fn : int * int -> int
	val double_n_times = <hidden-value> : int * int -> int
	val nth_tail = <hidden-value> : int * 'a list -> 'a list
	val n_times = fn : ('a -> 'a) * int * 'a -> 'a
	val increment = fn : int -> int
	val double = fn : int -> int
	val x1 = 112 : int
	val x2 = 11 : int
	val x3 = [12,16] : int list
	val addition = fn : int * int -> int
	val double_n_times = fn : int * int -> int
	val nth_tail = fn : int * 'a list -> 'a list
	val triple_n_times = fn : int * int -> int
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Modeling a poker game in Scala

WORK IN PROGRESS. If I find the time ideally i'd like to develop a PLAY2.x app using AKKA actors to orchestrate the poker game. Would be a very nice exercise. :)

	package patterns
	object PokerGame {
	sealed trait Suit
	case object Clubs extends Suit
	case object Diamonds extends Suit
	case object Hearts extends Suit
	case object Spades extends Suit
	sealed trait Rank
	case object Jack extends Rank
	case object Queen extends Rank
	case object King extends Rank
	case object Ace extends Rank
	case class Numeric(value: Int) extends Rank
	sealed trait Color
	case object Red extends Color
	case object Black extends Color
	sealed trait Value
	case object StraightFlush extends Value
	case object FourOfKind extends Value
	case object FullHouse extends Value
	case object Flush extends Value
	case object Straight extends Value
	case object ThreeOfKind extends Value
	case object TwoPair extends Value
	case object Pair extends Value
	case class HighCard(value: Int) extends Value
	type Card = (Suit, Rank)
	type Hand = (Card, Card, Card, Card, Card)
	val D1 = (Diamonds, Numeric(1))
	val D2 = (Diamonds, Numeric(2))
	val D3 = (Diamonds, Numeric(3))
	val D4 = (Diamonds, Numeric(4))
	val D5 = (Diamonds, Numeric(5))
	val D6 = (Diamonds, Numeric(6))
	val D7 = (Diamonds, Numeric(7))
	val D8 = (Diamonds, Numeric(8))
	val D9 = (Diamonds, Numeric(9))
	val D10 = (Diamonds, Numeric(10))
	val DJ = (Diamonds, Jack)
	val DQ = (Diamonds, Queen)
	val DK = (Diamonds, King)
	val DA = (Diamonds, Ace)
	val S1 = (Spades, Numeric(1))
	val S2 = (Spades, Numeric(2))
	val S3 = (Spades, Numeric(3))
	val S4 = (Spades, Numeric(4))
	val S5 = (Spades, Numeric(5))
	val S6 = (Spades, Numeric(6))
	val S7 = (Spades, Numeric(7))
	val S8 = (Spades, Numeric(8))
	val S9 = (Spades, Numeric(9))
	val S10 = (Spades, Numeric(10))
	val SJ = (Spades, Jack)
	val SQ = (Spades, Queen)
	val SK = (Spades, King)
	val SA = (Spades, Ace)
	val H1 = (Hearts, Numeric(1))
	val H2 = (Hearts, Numeric(2))
	val H3 = (Hearts, Numeric(3))
	val H4 = (Hearts, Numeric(4))
	val H5 = (Hearts, Numeric(5))
	val H6 = (Hearts, Numeric(6))
	val H7 = (Hearts, Numeric(7))
	val H8 = (Hearts, Numeric(8))
	val H9 = (Hearts, Numeric(9))
	val H10 = (Hearts, Numeric(10))
	val HJ = (Hearts, Jack)
	val HQ = (Hearts, Queen)
	val HK = (Hearts, King)
	val HA = (Hearts, Ace)
	val C1 = (Clubs, Numeric(1))
	val C2 = (Clubs, Numeric(2))
	val C3 = (Clubs, Numeric(3))
	val C4 = (Clubs, Numeric(4))
	val C5 = (Clubs, Numeric(5))
	val C6 = (Clubs, Numeric(6))
	val C7 = (Clubs, Numeric(7))
	val C8 = (Clubs, Numeric(8))
	val C9 = (Clubs, Numeric(9))
	val C10 = (Clubs, Numeric(10))
	val CJ = (Clubs, Jack)
	val CQ = (Clubs, Queen)
	val CK = (Clubs, King)
	val CA = (Clubs, Ace)
	def valueOf(rank: Rank): Int = rank match {
	case Ace => 14
	case King => 13
	case Queen => 12
	case Jack => 11
	case Numeric(n) => n
	}
	def colorOf(suit: Suit): Color = suit match {
	case Clubs => Black
	case Spades => Black
	case _ => Red
	}
	def toRanks(hand: Hand): List[Rank] = {
	val ((suit1, rank1), (suit2, rank2), (suit3, rank3), (suit4, rank4), (suit5, rank5)) = hand
	List(rank1, rank2, rank3, rank4, rank5)
	}
	def toSuites(hand: Hand): List[Suit] = {
	val ((suit1, rank1), (suit2, rank2), (suit3, rank3), (suit4, rank4), (suit5, rank5)) = hand
	List(suit1, suit2, suit3, suit4, suit5)
	}
	def toColors(hand: Hand): List[Color] = toSuites(hand).map(colorOf _)
	def toRankValues(hand: Hand): List[Int] = toRanks(hand).map(valueOf _)
	def toRankSizes(hand: Hand): List[Int] =
	toRanks(hand).groupBy(identity).map { case (rank, listofranks) => listofranks.size } .toList
	def isSameSuit(hand: Hand): Boolean = toSuites(hand).forall(_ == hand._1._1)
	def isStraightFlush(hand: Hand): Boolean = isSameSuit(hand) && isStraight(hand)
	def isFourOfKind(hand: Hand): Boolean = toRankSizes(hand).exists(_ >= 4)
	def isFullHouse(hand: Hand): Boolean = {
	val rankSizes = toRankSizes(hand)
	rankSizes.exists(_ == 2) && rankSizes.exists(_ == 3)
	}
	def isFlush(hand: Hand): Boolean = isSameSuit(hand)
	def isStraight(hand: Hand): Boolean = {
	val rankValues = toRankValues(hand)
	val minimumRankValue = rankValues.min
	rankValues.toSet == minimumRankValue.to(minimumRankValue + 4).toSet
	}
	def isThreeOfKind(hand: Hand): Boolean = toRankSizes(hand).exists(_ >= 3)
	def isTwoPair(hand: Hand): Boolean = toRankSizes(hand).filter(_ >= 2).size == 2
	def isPair(hand: Hand): Boolean = toRankSizes(hand).exists(_ >= 2)
	def evaluate(hand: Hand): Value =
	if (isStraightFlush(hand)) StraightFlush
	else if (isFourOfKind(hand)) FourOfKind
	else if (isFullHouse(hand)) FullHouse
	else if (isFlush(hand)) Flush
	else if (isStraight(hand)) Straight
	else if (isThreeOfKind(hand)) ThreeOfKind
	else if (isTwoPair(hand)) TwoPair
	else if (isPair(hand)) Pair
	else HighCard(toRankValues(hand).sorted.reverse.toList(0))
	/** for unit testing
	val straightflush = (D10, DJ, DQ, DK, DA)
	val fourofkind = (H10, HQ, C10, S10, D10)
	val fullhouse = (H10, D10, SJ, C10, CJ)
	val flush = (D3, D5, D8, DJ, DA)
	val straight = (D6,H4, C3, H5, S7)
	val threeofkind = (H10, HQ, CK, S10, D10)
	val twopair = (H10, HQ, CK, S10, DQ)
	val pair = (H9, HQ, CK, S10, D10)
	val highcard = (HK, S5, S2, C7, D9)
	val test1 = evaluate(straightflush) == StraightFlush
	val test2 = evaluate(fourofkind) == FourOfKind
	val test3 = evaluate(fullhouse) == FullHouse
	val test4 = evaluate(flush) == Flush
	val test5 = evaluate(straight) == Straight
	val test6 = evaluate(threeofkind) == ThreeOfKind
	val test7 = evaluate(twopair) == TwoPair
	val test8 = evaluate(pair) == Pair
	val test9 = evaluate(highcard) == HighCard(13)
	**/
	}

view raw gistfile1.scala hosted with ❤ by GitHub

transforming non tail recursive functions in tail recursive ones

	(* non tail recursive *)
	fun sum xs =
	case xs of
	[] => 0
	| x::xs' => x + sum xs'
	fun sumtailrecursive xs =
	let fun aux(xs,acc) =
	case xs of
	[] => acc
	| x::xs' => aux(xs', x + acc)
	in
	aux(xs,0)
	end
	(* whenever recursive operations are commutative we can use this approach
	of defining an auxiliary function which takes an extra accumulator parameter
	e.g. for summing or multiplying because
	3 * 4 == 4 * 3
	3 + 5 == 5 + 3
	*)
	(* non tail recursive *)
	fun reverse xs =
	case xs of
	[] => []
	| x::xs' => (reverse xs') @ [x]
	(* tail recursive *)
	fun reverse xs =
	let fun aux(xs, acc) =
	case xs of
	[] => acc
	| x::xs' => aux(xs', x::acc)
	in
	aux(xs,[])
	end

view raw gistfile1.sml hosted with ❤ by GitHub

raising and handling exceptions in ML

	fun hd xs =
	case xs of
	[] => raise List.empty
	| x::_ => x
	exception MyUndesirableCondition
	exception MyOtherException of int * int
	fun mydiv (x,y) =
	if y=0
	then raise MyUndesirableCondition
	else x div y
	fun maxlist (xs,ex) =
	case xs of
	[] => raise ex
	| x::[] => x
	| x::xs' => Int.max(x, maxlist(xs',ex))
	(* val y = maxlist ([], MyUndesirableCondition) *)
	val z = maxlist([], MyUndesirableCondition) handle MyUndesirableCondition => 42

view raw gistfile1.sml hosted with ❤ by GitHub

Using nested pattern matching (ML)

	fun zip3 list_triple =
	case list_triple of
	([],[],[]) => []
	|(hd1:tl1, hd2:tl2, hd3:tl3) => (hd1,hd2,hd3) :: zip3 (tl1,tl2,tl3)
	| _ => raise ListLengthMismatch
	fun unzip lst =
	case lst of
	[] => ([],[],[])
	|(a,b,c)::tl => let val (l1,l2,l3) = unzip tl
	in
	(a::l1, b::l2, c::l3)
	end
	fun nondecreasing xs = (* int list -> bool *)
	case xs of
	[] => true
	| _::[] => true
	| head::(neck::rest) => head <= neck andalso nondecreasing (neck::rest)
	datatype sign = Positive | Negative | Zero
	fun multsign (x1, x2) = (* int * int -> sign *)
	let fun sgn x = if x = 0 then Zero else if x > 0 then Positive else Negative
	in
	case (sgn x, sgn y) of
	(Positive, Positive) => Positive
	| (Negative, Negative) => Positive
	| (Zero, _) => Zero
	| (_, Zero) => Zero
	| _ => Negative
	end

view raw gistfile1.sml hosted with ❤ by GitHub

Pattern matching on each-of types (bad vs good style) ML

	fun sum_triple_bad_style triple =
	case triple of (x,y,z) => x + y + z
	fun sum_triple_better_style triple =
	let val (x,y,z) = triple
	in
	x + y + z
	end
	fun sum_triple_best_style (x,y,z) = x + y + z
	(*
	assume a record looks like
	{ first="Robby", last="Pelssers"}
	*)
	fun full_name_bad_style r =
	case r of {first=f, last=l} => f ^ " " ^ l
	fun full_name_better_style r =
	let val {first=f, last=l} = r
	in
	f ^ " " ^ l
	end
	fun full_name_best_style {first=f, last=l} = f ^ " " ^ l
	val sum1 = sum_triple_bad_style (1,2,3)
	val sum2 = sum_triple_better_style (1,2,3)
	val sum3 = sum_triple_best_style (1,2,3)
	val fullname1 = full_name_bad_style({first="Robby", last="Pelssers"})
	val fullname2 = full_name_better_style({first="Robby", last="Pelssers"})
	val fullname3 = full_name_best_style({first="Robby", last="Pelssers"})
	(* output of program
	- use "patterns.sml";
	[opening patterns.sml]
	val sum_triple_bad_style = fn : int * int * int -> int
	val sum_triple_better_style = fn : int * int * int -> int
	val sum_triple_best_style = fn : int * int * int -> int
	val full_name_bad_style = fn : {first:string, last:string} -> string
	val full_name_better_style = fn : {first:string, last:string} -> string
	val full_name_best_style = fn : {first:string, last:string} -> string
	val sum1 = 6 : int
	val sum2 = 6 : int
	val sum3 = 6 : int
	val fullname1 = "Robby Pelssers" : string
	val fullname2 = "Robby Pelssers" : string
	val fullname3 = "Robby Pelssers" : string
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Examples of using polymorphic datatypes ML

	datatype 'a option = NONE | SOME of 'a
	datatype 'a mylist = EMPTY | Cons of 'a * 'a mylist
	datatype ('a,'b) tree =
	Node of 'a * ('a,'b) tree * ('a,'b) tree
	| Leaf of 'b
	val sometree = Node( 1, Leaf(2), Node(3, Leaf(4),Leaf(5)) );
	(* output of program
	- use "polymorphic.sml";
	[opening polymorphic.sml]
	datatype 'a option = NONE | SOME of 'a
	datatype 'a mylist = Cons of 'a * 'a mylist | EMPTY
	datatype ('a,'b) tree = Leaf of 'b | Node of 'a * ('a,'b) tree * ('a,'b) tree
	val sometree = Node (1,Leaf 2,Node (3,Leaf #,Leaf #)) : (int,int) tree
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Using pattern matching instead of using head or tail

	(* in a previous post we saw how we could define a max function by testing
	- if a list is empty with null
	- extracting a value from an option with valOf
	BUT that is considered bad practise so instead we will switch to using pattern matching
	Because both list AND option are defined as algebraic datatypes
	fun max(numbers: int list) =
	if null numbers
	then NONE
	else
	let val max_tail = max(tl numbers)
	in
	if max_tail = NONE orelse hd numbers >= valOf max_tail
	then SOME (hd numbers)
	else max_tail
	end;
	can be rewritten to
	*)
	fun max(numbers: int list): int option =
	case numbers of
	[] => NONE
	| x::xs =>
	case max xs of
	NONE => SOME x
	|SOME y => SOME (Int.max(x, y))
	val test1 = max([3,6,4,2])
	val test2 = max([])
	(* output of program
	[opening patternmatching.sml]
	val max = fn : int list -> int option
	val test1 = SOME 6 : int option
	val test2 = NONE : int option
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Simple example of using a recursive datatype (ML)

	datatype exp = Constant of int
	| Negate of exp
	| Add of exp * exp
	| Multiply of exp * exp
	fun eval e =
	case e of
	Constant i => i
	| Negate e2 => ~ (eval e2)
	| Add(e1,e2) => (eval e1) + (eval e2)
	| Multiply(e1,e2) => (eval e1) * (eval e2)
	fun max_constant e =
	case e of
	Constant i => i
	| Negate e1 => max_constant e1
	| Add(e1,e2) => Int.max(max_constant e1,max_constant e2)
	| Multiply(e1,e2) => Int.max(max_constant e1,max_constant e2)
	val example_exp = Add (Constant (10+9), Negate (Constant 4))
	val result = eval example_exp
	val maxconstant = max_constant example_exp
	(* output of program
	- use "expression.sml";
	[opening expression.sml]
	datatype exp
	= Add of exp * exp | Constant of int | Multiply of exp * exp | Negate of exp
	val eval = fn : exp -> int
	val max_constant = fn : exp -> int
	val example_exp = Add (Constant 19,Negate (Constant 4)) : exp
	val result = 15 : int
	val maxconstant = 19 : int
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Datatypes in ML

	datatype mytype =
	TwoInts of int * int
	|Str of string
	|Pizza
	fun f(x: mytype) =
	case x of
	Pizza => 3
	|Str s => 8
	|TwoInts(i1,i2) => i1 + i2
	val a = Str "hi"
	val b = Pizza
	val c = TwoInts(2,3)
	val d = f c
	val e = f Pizza
	(* output of program
	use "datatypes.sml";
	[opening datatypes.sml]
	datatype mytype = Pizza | Str of string | TwoInts of int * int
	val f = fn : mytype -> int
	val a = Str "hi" : mytype
	val b = Pizza : mytype
	val c = TwoInts (2,3) : mytype
	val d = 5 : int
	val e = 3 : int
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Records and tuples as syntactic sugar for records (ML)

	val product1 = {name="Iphone 5", price=400, madeByApple=true};
	val productname = #name product1;
	(* tuples are just syntactic sugar for records *)
	val product2 = {1="GalaxyS4", 2=400};
	val price = #2 product2;
	(* output of program
	- use "records.sml";
	[opening records.sml]
	val product1 = {madeByApple=true,name="Iphone 5",price=400}
	: {madeByApple:bool, name:string, price:int}
	val productname = "Iphone 5" : string
	val product2 = ("GalaxyS4",400) : string * int
	val price = 400 : int
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

A taste of programming in ML

Taking a new course Proglang which started this week. So expect more to follow on what I learn.

	(* returns NONE if list is empty, else SOME (maxnumber) *)
	fun max(numbers: int list) =
	if null numbers
	then NONE
	else
	let val max_tail = max(tl numbers)
	in
	if max_tail = NONE orelse hd numbers >= valOf max_tail
	then SOME (hd numbers)
	else max_tail
	end;
	(* concatenates all strings using separator *)
	fun stringjoin(strings: string list, separator: string) =
	if null strings
	then ""
	else if null (tl strings)
	then hd strings
	else hd strings ^ separator ^ stringjoin(tl strings, separator);
	(* date is tuple of form (year, month, day) -> returns boolean *)
	fun isLeapYear(date: int*int*int) =
	#1 date mod 400 = 0 orelse (#1 date mod 4 = 0 andalso #1 date mod 100 <> 0)
	(* filter all even numbers *)
	fun filterEven(numbers: int list) =
	if null numbers
	then []
	else if hd numbers mod 2 = 0
	then hd numbers :: filterEven(tl numbers)
	else filterEven(tl numbers);

view raw gistfile1.sml hosted with ❤ by GitHub