MySuperType mySuperObject = new MySuperType();

D>>Правда это как раз и есть то, что используют и Хаскелл, и ML

function id ( x )
{
    return x;
}

def main()
{
    local b = "PECHEN TRESKI";
    local c;

    c = b + 1;
}
||
\/
FFFF {3} {3}       JMP    000F ; [0D 13 00]  
0003 {2} {2} 0011: DATA   000D ; [0D 00] len: 13 'PECHEN TRESKI' 
FFFF {2} {2}       DATA   4550 ; [50 45]  
FFFF {2} {2}       DATA   4843 ; [43 48]  
FFFF {2} {2}       DATA   4E45 ; [45 4E]  
FFFF {2} {2}       DATA   5420 ; [20 54]  
FFFF {2} {2}       DATA   4552 ; [52 45]  
FFFF {2} {2}       DATA   4B53 ; [53 4B]  
FFFF {2} {2}       DATA   0049 ; [49 00]  
0013 {3} {3} 000F: LIT    0000 ; [29 00 00] b#0 -- main 
FFFF {3} {3}       LIT    0000 ; [29 00 00] c#0 
FFFF {3} {3}       SF     0001 ; [07 01 00] main 
FFFF {1} {1}       NOP         ; [00  ]  
FFFF {3} {3}       ADDROF 0011 ; [29 03 00]  
FFFF {1} {1}       STORE0      ; [34  ] -> b#0 
FFFF {1} {1}       LOAD0       ; [2C  ] b#0 
FFFF {1} {1}       INC         ; [13  ]  <- (*1)
FFFF {1} {1}       STORE1      ; [35  ] -> c#0 
0024 {1} {1} 0010: DOWN        ; [FF  ] 

(*1) - вот тут, вместо того, что бы сделать что-то полезное, если определена операция (+) (string, int) 
или сгенерировать ошибку - мы прибавили к ссылке единицу. нехорошо вышло. но это только проверка типов.

(* BUILTINS *)

BUILTIN beepvm_do_something  do_somethin : вот что мне тут написать, что бы компилятор понял, что возращаемое значение - список списков строк?

...

BUILTIN beepvm_put_char putc(1)
BUILTIN beepvm_put_int  put_int(1)
BUILTIN beepvm_put_str  puts(1)            
BUILTIN beepvm_gc       alloc(1)        EMIT(ALLOC)
BUILTIN beepvm_gc       gc(0)           EMIT(GC)
BUILTIN beepvm_gc_cheap gc_cheap(0)     EMIT(CGC)
BUILTIN beepvm_dump     debug_dump(0)   EMIT(DUMP)

def function(a:int, b:string)

local a = [[[1,2],[1,2]],[[1,2],[1,2]]];

a[0]     # <- Тип?
a[0][0]  # <- Тип ?

Unfortunately, type information is very hard to represent and manipulate efficiently, especially when the underlying type system involves ML-like polymorphic types and module types. A naive implementation can easily add exponential overhead to the compilation and execution of a program.
...
We describe several different ways of representing type variables bound in the term languages and then compare their performance.

dmz>def function(a:int, b:string) 
dmz>

def main()
{
    local b = "PECHEN TRESKI";
    local c = foo("GOLOVA MINTAYA", 1);
    local d = foo(2, "KIL`KIN HVOST");
    c = b + 1;
}

local b = "PECHEN TRESKI";

local c = foo("GOLOVA MINTAYA", 1);

local d = foo(2, "KIL`KIN HVOST");

type_error: (fun(string,int), int) != (fun(int, string), int)

local d = foo(2, "KIL`KIN HVOST");
type_error: (fun(string,int), int) != (fun(int, string), int)

id :: forall a . a -> a
id x = x

foo :: String
foo = id "Вася"
-- здесь id мономорфизируется и получает тип String -> String, благодаря вызову с "Васей"

let type_of ast_node ast = ...