(* References *)

val r = ref 0
val s = ref 0
val a = r=s
val _ = r := 3
val x = !s + !r
val t = r
val b = s=t
val c = r=t
val _ = t := 5
val y = !s + !r
val z = !t + !r

fun rot3 (a, b, c) =
    let
        val t = !a
    in
        a := !b; b := !c; c := t
    end

fun rot3 (a, b, c) =
    let
        val (x, y, z) = (!a, !b, !c)
    in
        a := y; b := z; c := x
    end

fun rot3 (a, b, c) =
    let
        val (ref x, ref y, ref z) = (a, b, c)
    in
        a := y; b := z; c := x
    end

fun imperative_fact (n:int) =
    let
        val result = ref 1
        val i = ref 0
        fun loop () =
            if !i = n then
               ()
            else
               (i := !i + 1; result := !result * !i; loop ())
    in
        loop (); !result
    end

local
      val counter = ref 0
in
      fun tick () = (counter := !counter + 1; !counter)
      fun reset () = (counter := 0)
end

fun new_counter () =
    let
        val counter = ref 0
        fun tick () = (counter := !counter + 1; !counter)
        fun reset () = (counter := 0)
    in
        { tick = tick, reset = reset }
    end

val c1 = new_counter ()
val c2 = new_counter ()
#tick c1;                 (* 1 *)
#tick c1;                 (* 2 *)
#tick c2;                 (* 1 *)
#reset c1;
#tick c1;                 (* 1 *)
#tick c2;                 (* 2 *)

datatype 'a pcl = Nil | Cons of 'a * 'a pcl ref

fun hd (Cons (h, _)) = h          (* auxiliary functions *)
fun tl (Cons (_, t)) = t

val ones = Cons (1, ref Nil)     (* create a preliminary acyclic structure *)

val _ = (tl ones) := ones        (* backpatch to form the cycle *)

fun C 1 = 1
  | C n = sum (fn k => (C k) * (C (n-k))) (n-1)

local
       val limit : int = 100
       val memopad : int option array = Array.array (limit, NONE)
in
       fun C' 1 = 1
         | C' n = sum (fn k => (C k) * (C (n-k))) (n-1)
       and C n =
           if n < limit then
              case Array.sub (memopad, n)
                of SOME r => r
                 | NONE =>
                   let
                       val r = C' n
                   in
                       Array.update (memopad, n, SOME r);
                       r
                   end
            else
               C' n
end