(* Code of some examples *)

(* Change the print depth of the compiler by adjusting
   a reference buried deep in the compiler.
*)

Compiler.Control.Print.printDepth := 20;

(* Enumerate types *)

datatype compass = north | east | south | west;

fun rotate north = east
  | rotate east  = south
  | rotate south = west
  | rotate west = north;

(* Types including other types *)

datatype number = I of int | R of real;

fun plus(I n, I m) = I (n + m)
  | plus(I n, R r) = R (real n + r)
  | plus(R r, I n) = R (r + real n)
  | plus(R r, R s) = R (r + s);

fun add1 nil = nil
  | add1(I n :: L) = (I(n + 1) :: add1 L )
  | add1(R r :: L) = (R(r + 1.0) :: add1 L);

datatype btree = Empty | Node of int * btree * btree;

fun insert(n,Empty) = Node(n,Empty,Empty)
  | insert(n,Node(m,left,right)) =
      if n <= m then Node(m,insert(n,left),right)
                else Node(m,left,insert(n,right));

val ex1 = insert(10, insert(8, insert(5, insert(9,Empty))));

fun lookup(_,Empty) = false
  | lookup(n,Node(m,left,right)) =
     if n = m then true else
               if n < m then lookup(n,left) else lookup(n,right);

fun in_order_traversal Empty = nil
  | in_order_traversal(Node(n,left,right)) = 
       in_order_traversal left @ (n::in_order_traversal right);

fun insertList nil = Empty
  | insertList(n::l) = insert(n,insertList l);

fun bsort L = in_order_traversal (insertList L);

fun sumtree Empty = 0
  | sumtree(Node(n,left,right)) = sumtree left + n + sumtree right;

fun optree (Op, Empty) = 0
  | optree (Op, Node(n,left,right)) = 
     Op( optree(Op, left), Op(n, optree (Op, right)));