signature DIRECT3D =
  sig
    type device
    type vertex_buffer

    val newDevice : (* ... *) -> device
    val newVertexBuffer : device * (* ... *) -> vertex_buffer
    val setStreamSource : device * vertex_buffer * (* ... *) -> unit
    (* ... *)
  end
structure Direct3D :> DIRECT3D = struct (*...*) end

def f(a, b) return a + b; end

fib :: a -> a | + a & - a & one a & < a
fib n
   | n < two   = one
   | otherwise = fib(n-one) + fib(n-two)
   where two = one+one

class MyObj {
   public void doStuff(){}
   public static void main(String[] args) {
      Object o = new MyObj();
      o.doStuff();
    }
}

class Base {
  Base inc() {
    // do increment
    return this;
  }
}
 
class Derrived {
  Derrived dec() {
    // do decrement
    return this;
  }
}
 
...
 
Derrived d = new Derrived();
d.inc().dec(); // Error - Base doesn't have a dec

class Base {
  this inc() { // declared as returning this ***and*** only this
    // do increment
    return this;
  }
}
 
class Derrived {
  this dec() {
    // do decrement
    return this;
  }
}
 
...
 
Derrived d = new Derrived();
d.inc().dec(); // OK - d has a dec

class MyObj {
   public void doStuff(){}
   public static void main(String[] args) {
      Object o = new MyObj();
      o.doStuff();
    }
}

   public static void main(String[] args) {
      MyObj o = new MyObj();
      o.doStuff();
    }

   public static void main(String[] args) {
      let o = new MyObj();
      o.doStuff();
    }

class MyObj {
    public void doStuff(){}
    public static void main(String[] args) {
       Object o = new MyObj();
       o.doStuff();
    }
}

class MyObj
    def doStuff() end
end
 
o = MyObj.new
o.doStuff

int x; // x is an integer
int|string x; // x is a string or an integer
array(string) x; // x is an array of strings
array x; // x is an array of mixed
mixed x; // x can be any type
string *x; // x is an array of strings
 
// x is a mapping from int to string
mapping(string:int) x;
 
// x implements Stdio.File
Stdio.File x;
 
// x implements Stdio.File
object(Stdio.File) x;
 
// x is a function that takes two integer
// arguments and returns a string
function(int,int:string) x;
 
// x is a function taking any amount of
// integer arguments and returns nothing.
function(int...:void) x;
 
// x is ... complicated
mapping(string:function(string|int...:mapping(string:array(string)))) x;