note from UW PL course

31

• function里面的参数实际上都是只有一个的，然后使用pattern matching来进行操作，这也是函数能够返回多个值的原理。

32 type inference

• 不适用pattern match的话就要specify参数的个数，
• patten match里面没有出现的参数可以是任何参数, unexpected polymorphism..

33 polymorphism

• not ok to use 'a type in different types, should be the SAME in the context
• always choose the type which is more loose, or bigger

equality type 可以用= 比较的类型， ''a

34 nested patterns

• do it elegantly.
• 3个以上的pattern?
• leave the last condition in one.

37 function binding

• just another way of case expression.
• not overload function?

38 exception

• define yourself an exception
• raise & handle

39 tail recursion

• on call stack

fun fact n = if n = 0 then 1 else n* fact(n-1)

fun fact n = 
    let fun aux (n, acc) =
        if n = 0
        then acc
        else aux(n-1, acc*n)
    in 
        aux(n, 1)
    end

• tail recursion is as efficient as a loop => no call stack!
• remove the caller before the call ends, since the callee's result will be returned without any evaluation
• recognize tail recursion from compiler

Sometimes you could not write tail recursive function...

---

42 functions

• first-class functions, use as argument
• function closure
• high order function, polymorphic
• some polymorphic functions are not high-order

45 anonymous functions

• fn x => 3*x
• no recursive, (no name)
• unnecessary function wrapping, (use the original name)

47 map & filter

49 lexical scope

• the function's value will not be mutated, it is depend on the environment where it is defined.
• closure, no dynamic scope
• the condition will be recomputed

53 fold

• iterator like programming paradigm， apply parameter to each order

55 currying

multiple arguments

fun f x y z = x>y andalso y > z

fun f (x, y, z) = x>y andalso y > z

56 partial application

function with part parameter as function instanitiated

not work with polymorphic functions

57 currying wrapup

和tuple封装的替换，或者参数的顺序替换

58 mutable references

t ref // t is a type
ref e 
e1 := e2
!e

59 callbacks

val cbs : (int -> unit) list ref = ref []


fun onEvent i =
  let fun loop fs =
	case fs of
	    [] => ()
	  | f::fs' => (f i; loop fs')
  in loop (!cbs) end

fun onKeyEvent f =
  cbs := f::(!cbs)

val timePressed = ref 0
val _ = onKeyEvent(fn _ => timePressed := !timePressed + 1)

fun printIfPressed i =
  onKeyEvent (fn j =>
		 if i = j
		 then print ("pressed" ^ Int.toString i ^ "
")
		 else ()
	     )