DEFINE_CLASS_WITH_UNIQUE_NAME
{
    ...
    тут нельзя написать конструктор потому что мы не знаем имя класса
};

DEFINE_CLASS(Foo)
{
    ...
    DEFINE_CTOR(Foo) // тут опять надо зачем-то писать имя класса 
    {
        ...
    }
};

public class A
{
   public A();
}

public class A
{
   public ctor();
}

def Func1() int {}
redef Func2(int x, y) char {}

ctor InitDefault() {}
ctor InitFromStr(string s) {}

ctor() {}
ctor(string s) {}

new MyClass();
new MyClass("my text");

new<MyClass>("my text");

class Callback<X>{
operator (X x) {fp(x)};
this(FuncPointer fp)
{
    this.fp = fp;
}

this(Callback<X> other)
{
     this(other.fp); //вызов оператора() или конструктора?
}

XC>Мой вариант, критикуйте

class Rectangle {
  public function getLeft() : int;
  public function getRight() : int;
  public function getTop() : int;
  public function getBottom() : int;
  public function getWidth() : int;
  public function getHeight() : int;
  public function expandWidth(amount : int) : Rectangle; // Вовзращает прямоугольник с шириной, увеличенной на amount
}

1. Instance initialization method — инициализация экземпляра. Выполняет следующие действия:
   
   • Инициализация полей класса по-умолчанию
     
   • Выполнение Instance initialization method предка (предков)
     
   • Выполнение произвольного User-defined кода
2. Instance creation method — создание экземпляра. Выполняет следующие действия:
   
   • Выделяет память под экземпляр класса
     
   • Инициализирует таблицу виртуальных методов
     
   • Вызывает initialization method

smth.method ====>
function(...args) {
  SmthType.method.apply([smth].concat(args));
}

  new Rectangle(1, 2, 3, 4);

new Rectangle.bySize(...) ====>
[bySize returning Rectangle](...)

new Rectangle.createRectangle(rf) ===>
[createRectangle returning Rectangle](rf) <====
rf.createRectangle()

class Rectangle {
  ctor (...args)
} ====>

class Rectangle {
  ctor new(...args) : Rectangle {...}
}

var x = Rectangle.new(....);

declare String is CharSequence with 
    function str → new StringCharSequenceAdapter(str)

declare FileOutputStream is OutputStream with 
    function stream → {
   close = close stream
   write = write stream
   ...
}
Ну или, с сахаром
declare FileOutputStream is OutputStream auto by-name

let wrapSomeMethod iface = iface with { someMethod = wrap (iface.someMethod) }

interface type Z = {methodA : int -> String; methodB : String -> int }
будет еще генерировать
let methodA (z : Z, i : int) -> z.methodA(i)
let methodB (z : Z, s : String) -> z.methodB(s)

type derived = record
    base : parent,
    … какие-то еще данные
end

declare derived is base with 
    function der → der.base

type IOStream = record
  base : Stream
  inputStream : Istream
  outputStream : Ostream
end

declare IOStream is Stream with
    function str → str.base
delcare IOStream is Istream with
    function str → str.inputStream
declare IOStream is Ostream with
    function str → str.outputStream

let createFileIOStream fname = 
  let baseStream = createFileStream fname in
  { base : baseStream,
     inputStream : createInputStream(baseStream),
     outputStream : createOutputStream(baseStream)
  }

let createSomethingWithA args = createSomething args { methodA : … }
let createSomethingWithB args = createSomething args { methodB : … }
let createSomethingWithAandB args = createSomething args { methodA : …; methodB : … }

Let callProtected x = x.protMethod {
  dispose : x.dispose
  draw : x.draw
}

with something {
  // здесь методы сначала разрешаются как методы или поля something и только потом из внешнего контекста.
}
ну и сахар 
defmethod method Type (args …)  … =>
let method instance args …
    with instance
        ….

//Определение класса
class x === type t
interface Y === type Y = record {
  methodA : <type>;
  methodB : <type> ...
}

//Конструторы
public X(...) === export createX(...)
internal/private x(...) === createX(...) //внутренний для модуля

// Наследование
Z extends X === { super : X, ... } 
и declare Z is-a X with function z -> z.super

приватное "наследование". Точно так же, но без declare Z is-a ...

в конструторе
{ ... super(a, b, c) ... }  === let super_instance = createX(a, b, c) ... { super : super_instance, ...}

// реализация интерфейса
Z implements Y ===
declare Z is-a Y with function z -> { methodA : z.methodA, methodB : z.methodD, ...}
или
declare Z is-a Y auto by-name // в рамках видимых в данном контексте методов

// методы
public function zzz (args) {...} ===

let function zzz this : Z args =
  with this { ...
  }

"Extension method" выглядит точно так же, только находится в другом модуле.

//переопределение методов
override function zzz (args) { ... } ===
явно через конструтор:

type X {
  overrides : ...
}

let createX(constructuor-args, overrides) = { overrides : concatOverwrides(overwrides, DEFAULT_IMPLEMENTATIONS), .... }

// без наследования. Обычно если нужно переопределять методы, типы менять не нужно.
let createZ(constructuor-args, overrides2) = createX(constructor-args, concatOverwrired(overries2, DEFAULT_Z_IMPLEMENTATIONS))

VD>"new", кстати, тоже лишнее

public class MyClass
{
}

public class YourClass
{
    private static MyClass MyClass()
    {
       return null;
    }

    public YourClass()
    {
        // Syntax without 'new' keyword.
        // Is this invocation of Method or construction of object?
        MyClass x = MyClass();
    }
}

VD>>"new", кстати, тоже лишнее

A>public class MyClass
A>{
A>}

A>public class YourClass
A>{
A>    private static MyClass MyClass()
A>    {
A>       return null;
A>    }

A>    public YourClass()
A>    {
A>        // Syntax without 'new' keyword.
A>        // Is this invocation of Method or construction of object?
A>        MyClass x = MyClass();
A>    }
A>}


A>

class MyClass:
    def __init__(self):
        print "MyClass.__init__"

class YourClass:
    @staticmethod
    def MyClass():
        print "YourClass.MyClass"
        return None

    def __init__(self):
        x1 = MyClass()
        x2 = YourClass.MyClass()

y = YourClass()

MyClass.__init__
YourClass.MyClass

4.
class MyClass
{
 ();
 ~();
};

class MyClass
{
 public int Func();
};
MyClass obj;
obj.Func();
MyClass.Func(obj); // вот так тоже можно

вместо 
... object = ...
const callback : Function = function() : void {
  doSomethingWithObject(object);
}
add(new Button(new Action(callback)));

удобно было бы
... object = ...
add(new Button(object.doSomethingWithObject));

object.[some.module.Name:doSomethingWithObject]

• Возможности получать для одноаргументных методов "хитрое" замыкание. Уже показывал где-то, передать функцию, работающую над заданным объектом, а не результат выполнения этой функции. Пусть даже через value.method и вызов этого метода value.method () вместо method value. Делается вручную, но так как часто нужно — не очень красиво.
  
• Возможность разрешения функций по первому типу аргумента. Т.е., например при импорте open List; open Hashtbl при вызове fold smth ... выбирался бы fold, применимый к объекту (в зависимости от того, smth является списком или таблицей — List.fold или Hashtbl.fold). Пусть даже для этого опять нужно было бы использовать синтаксис smth.fold .... Перегрузки по другим типам (другим аргументам функции) не нужно. И вообще это даже не введение "перегруженных" методов, это просто механизм lookup для имени (из всех доступных выбирается доступное по типу первого аргумента). Это позволило бы не писать кучи лишних квалификаторов модулей (то, что List.fold нет я знаю, это для примера). Хотя вот не знаю, как такое "усовершенствование" повлияет на вывод типов.

O>4.
O>class MyClass
O>{
O> ();
O> ~();
O>};
O>

O>

class Stock(val name:String, val symbol:String, var price:Double, var change:Double){
}

class MyClass() {}

int Foo1(int x, int y);
int Bar1(int=>int f);
int Foo2(int z);
int Bar2(void=>int f);

Bar1(Foo1{100});   // x = 100, y остается аргументом 
Bar1(Foo1{_,200}); // y = 200, x остается аргументом 
Bar1(Foo1{.y=300});// y = 300, x остается аргументом 

Bar2(Foo2{300});

A(const A&); // объявили
...
A a(a1); // попросили компилятор вызвать

CopyConstructor(const A&); // объявили
...
A a(a1); // попросили.. хмм... ЧТО?

Object subclass: #Person 
    instanceVariableNames: 'firstName lastName' 
    category: 'OnSmalltalk'

person := (Person new)
                  firstName: 'Ramon'; 
                  lastName: 'Leon'; 
                  yourself.

Person class>>firstName: aFirstName lastName: aLastName
    ^(self new)
        firstName: aFirstName ;
        lastName: aLastName;
        yourself.

person := Person firstName: 'Ramon' lastName: 'Leon'.