Standard ML of New Jersey v110.60 [built: Thu Nov  9 15:44:30 2006]

**** Basic types and values...
- ();
val it = () : unit

- 3+5;
val it = 8 : int

- 100/2;
stdIn:1.1-11.3 Error: operator and operand don't agree [literal]
  operator domain: real * real
  operand:         int * int
  in expression:
    100 / 2

- 100 div 2;
val it = 50 : int

- 2-5;
val it = ~3 : int

- -3;
stdIn:37.1 Error: expression or pattern begins with infix identifier "-"
stdIn:37.1-37.3 Error: operator and operand don't agree [literal]
  operator domain: 'Z * 'Z
  operand:         int
  in expression:
    - 3

- 100/3.0;
stdIn:1.1-11.5 Error: operator and operand don't agree [literal]
  operator domain: real * real
  operand:         int * real
  in expression:
    100 / 3.0

-100.0/3.0;
val it = 33.3333333333 : real

*** Boolean values ***
- 3<>4;
val it = true : bool

- 4.0=4.0;
stdIn:65.1-65.8 Error: operator and operand don't agree [equality type required]
  operator domain: ''Z * ''Z
  operand:         real * real
  in expression:
    4.0 = 4.0

- (4.3>1.4) andalso ("hello1" = "hello");
val it = false : bool

*** Declaration ***
- val a = 4;
val a = 4 : int

- val b = 6;
val b = 6 : int

- a + b;
val it = 10 : int

- val x = a+b;
val x = 10 : int

- val str = "Hello world";
val str = "Hello world" : string

- print str;
Hello worldval it = () : unit

- print str ^ "\n";
stdIn:1.1-2.6 Error: operator and operand don't agree [tycon mismatch]
  operator domain: string * string
  operand:         unit * string
  in expression:
    print str ^ "\n"

- print (str ^ "\n");
Hello world
val it = () : unit

- val c = #"!";
val c = #"!" : char
- str ^ c;
stdIn:44.1-44.8 Error: operator and operand don't agree [tycon mismatch]
  operator domain: string * string
  operand:         string * char
  in expression:
    str ^ c
- str ^ (Char.toString c);
val it = "Hello world!" : string

*** Data structures ***

- type complexNum = real * real;
type complexNum = real * real

- val a = (3.0, 5.3);
val a = (3,5.3) : real * real

- (#2 a);
val it = 5.3 : int

- type complexNum1 = {real: real, imag: real};
type complexNum1 = {imag:real, real:real}

- val b = {real= 3.0, imag = 4.0};
val b = {real=3.0,imag=4.0} : {real:real, imag:real}

- (#imag b);
val it = 4.0 : real 

- datatype number = Int of int | Real of real;
datatype number = Int of int | Real of real

- val n = Int 2;
val n = Int 2 : number

- val m = Real of 2; 
= ;
stdIn:61.14 Error: syntax error found at OF

- val m = Real 2;
stdIn:11.2-38.2 Error: operator and operand don't agree [literal]
  operator domain: real
  operand:         int
  in expression:
    Real 2

- val m = Real 2.0;
val m = Real 2.0 : number

- m = n;
stdIn:63.1-63.6 Error: operator and operand don't agree [equality type required]
  operator domain: ''Z * ''Z
  operand:         number * number
  in expression:
    m = n

- 1::2::3::4;
stdIn:1.1-11.8 Error: operator and operand don't agree [literal]
  operator domain: int * int list
  operand:         int * int
  in expression:
    3 :: 4

- 1::(2::(3::4));
stdIn:11.6-11.10 Error: operator and operand don't agree [literal]
  operator domain: int * int list
  operand:         int * int
  in expression:
    3 :: 4

- 1::2::3::4::nil;
val it = [1,2,3] : int list

- 1::(2::(3::(4::nil)));
val it = [1,2,3] : int list

**** Some more pattern matching example

- val (3, x) = (3, 4);
stdIn:80.5-80.20 Warning: binding not exhaustive
          (3,x) = ...
val x = 4 : int

- val (x, y) = (4.0, 2);
val x = 4.0 : real
val y = 2 : int

- val {first = x, second = y} = {first=1.5, second = "abc"};
val x = 1.5 : real
val y = "abc" : string

- let val (x, y) = (1+2, 3*4) 
= in (x+y, x*y, x<y)
= end;
val it = (15,36,true) : int * int * bool

(*** Local declaration of x above! ***)
- case x of 
= 0 => "zero"
= | 1 => "one"
= | _ => "other";
stdIn:88.1-91.15 Error: case object and rules don't agree [literal]

- x;
val it = 1.5 : real

- val x = 3;
val x = 1 : int

- case x of
=   0 => "zero"
= | 1 => "one"
= | _ => "other";
val it = "other" : string

- case m of
=   Int _ => "int"
= | Real _ => "real";
val it = "real" : string

- val l = [1,2,3,4];
val l = [1,2,3,4] : int list

- let val (n::l) = l           
= in n*2
= end;
stdIn:14.9-14.19 Warning: binding not exhaustive
          n :: l = ...
val it = 2 : int

function example 

- val dec = fn x => x - 1;
val dec = fn : int -> int
- dec 5;
val it = 4 : int

- (dec 0);
val it = ~1 : int

- fun add (x, y) = x + y;
val add = fn : int * int -> int
- add (3.0, 2.3);
stdIn:24.1-24.15 Error: operator and operand don't agree [tycon mismatch]
  operator domain: int * int
  operand:         real * real
  in expression:
    add (3.0,2.3)

- fun add(x:real, y:real) : real = x + y;
val add = fn : real * real -> real
- add (3.0, 2.3);
val it = 5.3 : real

- fun mul x y = x * y;
val mul = fn : int -> int -> int
- mul (2, 3);
stdIn:27.1-27.11 Error: operator and operand don't agree [tycon mismatch]
  operator domain: int
  operand:         int * int
  in expression:
    mul (2,3)

- mul 2 3;
val it = 6 : int

- (mul 2) 3;
val it = 6 : int

*** Type inference ***
- fun divide x y = x / y;
val divide = fn : real -> real -> real

*** A little recursion now: print a list of numbers

- fun concat l =
= case l of   
=   nil => ""
= | n::l => (Int.toString n) ^ (concat l)
= ;
val concat = fn : int list -> string

- concat l;
val it = "1234" : string

- fun concat1 nil = ""
= | concat1 (n::l) = (Int.toString n) ^ (concat1 l);
val concat1 = fn : int list -> string

- concat1 l;
val it = "1234" : string

- fun fac n = if n<=0 then 1 else n * (fac (n-1));
val fac = fn : int -> int
- fac 5;
val it = 120 : int