class A
{
...
    int operator+(int);        //оператор сложения A+int
...
}

class A
{
...
    int opAdd(int);        //оператор сложения A+int - функция со "специальным" именем opAdd
...
}

A a;
double d = 1/a;     //как написать кастомный оператор для этого случая?

class A
{
...
};

double operator/(int, A&);

class A
{
    double opDiv_r(int, A&);    //opDiv + _r (right)
};

//C++
A a, b;
if(a == b)    ...            //вызов A.operator==
if(a != b)    ...            //вызов A.operator!=

//D
A a, b;
if(a == b)    ...            //вызов A.opEquals
if(a != b)    ...            //вызов !A.opEquals

//C++
A a, b;
if(a > b)    ...            //вызов A.operator>
if(a < b)    ...            //вызов A.operator<
//...и т.д.

//D
A a, b;
if(a <  b)    ...            //вызов A.opCmp(b) <  0
if(a >  b)    ...            //вызов A.opCmp(b) >  0
if(a <= b)    ...            //вызов A.opCmp(b) <= 0
if(a >= b)    ...            //вызов A.opCmp(b) >= 0

//Это - С++:
class A
{
    int val();                //getter
    int val(int _newval);    //setter (собака такая - сеттер)
}

A a;
int i = a.val();
a.val(i);

//==============================
//А вот это - уже D:
class A
{
    int val();                //getter
    int val(int _newval);    //setter
}

A a;
int i = a.val;    //вызывается A.val();
a.val = i;        //вызывается A.val(int);

int[] arr;        //что написано, то и есть - это динамический массив int'ов

for(int i = 0; i < arr.length; ++i)        //использование свойства массива .length

a.length = 42;                            //еще одно использование свойства

int maxint  = int.max;  //максимальное значение int'а
int sizeint = int.size;    //эта фенечка вместо С-шного sizeof(int)

float.nan                //NaN
float.infinity            //бесканечнасть

(2).max                    //эквивалентно int.max
2.max                    //ошибка - у числа 2 нету свойствов

int val = int.init;        //получим 0
int a;
val = a.init;            //получим 0 - потому что a было проинициализировано нулем

int b = 8;
val = b.init;            //получим 8

typedef int mycoolint = 2;
val = mycoolint.init;    //получим 2
mycoolint c;
val = c.init;            //получим 2

typedef uint Color; 
Color c; 
c += 28; // ошибка компиляции.

alias int myint; // это то что в C++ typedef.

ЗХ>//C++
ЗХ>A a, b;
ЗХ>if(a > b)    ...            //вызов A.operator>
ЗХ>if(a < b)    ...            //вызов A.operator<
ЗХ>//...и т.д.

ЗХ>//D
ЗХ>A a, b;
ЗХ>if(a <  b)    ...            //вызов A.opCmp(b) <  0
ЗХ>if(a >  b)    ...            //вызов A.opCmp(b) >  0
ЗХ>if(a <= b)    ...            //вызов A.opCmp(b) <= 0
ЗХ>if(a >= b)    ...            //вызов A.opCmp(b) >= 0
ЗХ>

struct    Compound_Key
{
    Some_Key_Type    a_;
    Another_Key_Type    b_;
};

bool operator( const Compound_Key & o ) const
    {
        return ( a_ < o.a_ || ( a_ == o.a_ && b_ < o.b_ ) );
    }

ЗХ>//C++
ЗХ>A a, b;
ЗХ>if(a > b)    ...            //вызов A.operator>
ЗХ>if(a < b)    ...            //вызов A.operator<
ЗХ>//...и т.д.

ЗХ>//D
ЗХ>A a, b;
ЗХ>if(a <  b)    ...            //вызов A.opCmp(b) <  0
ЗХ>if(a >  b)    ...            //вызов A.opCmp(b) >  0
ЗХ>if(a <= b)    ...            //вызов A.opCmp(b) <= 0
ЗХ>if(a >= b)    ...            //вызов A.opCmp(b) >= 0
ЗХ>

bool operator < (Some const& l, Some const& r)
{
...
}
bool operator > (Some const& l, Some const& r)
{
    return r < l;
}
bool operator <= (Some const& l, Some const& r)
{
    return !(r < l);
}
bool operator >= (Some const& l, Some const& r)
{
    return !(l < r);
}

For a native multiprocessor operating system, Aos is small, with a kernel of 7,210 lines of source or about 50KB of object code. For comparison, the 4.4BSD kernel (cf. 8.1.2) consists of 58,289 lines of C code (excluding file systems, network protocols and device drivers, which add another 143,962 lines) [65]. Version 2.4 of the Linux kernel consists of approximately 420,000 lines of C code (excluding drivers, file systems and architecture-specific code, which bring the total to 2.4 million lines) [128], and has a minimum size of around 500KB on Intel processors. Microsoft boasts that Windows 2000 “consists of over 29 million lines of code”, but does not say what is included in this figure, so it is not possible to compare specifics.

Subsystem        Lines

Kernel            7210
Service support   2532
File system       4624
User interface    2204
Network           6200
Oberon for Aos    8667

Total            31437

E>struct    Compound_Key
E>{
E>    Some_Key_Type    a_;
E>    Another_Key_Type    b_;
E>};
E>

Compound_Key a, b;
if(a < b) //так можно
if(a > b) //а так почему-то нельзя :(

Цель этого мне видится не в ознакомлении всего РСДНа с новым языком — а в обсуждении новых или не очень концепций D и их реализации.
(с) я.

E>>struct    Compound_Key
E>>{
E>>    Some_Key_Type    a_;
E>>    Another_Key_Type    b_;
E>>};
E>>

ЗХ>Compound_Key a, b;
ЗХ>if(a < b) //так можно
ЗХ>if(a > b) //а так почему-то нельзя :(
ЗХ>

class    Compound_Key
{
    int    opCmp( Compound_Key o )
    {
        if( a_ < o.a_ || ( a_ == o.a_ && b_ < o.b_ ) )
            return -1;
        // Оптимистично предполагаем, что всегда будет использоваться (c1<c2).
        return 0;
    }
};

E>Вообще-то я не думаю, что сравнение объектов, которые используются в качестве ключа map-а бессмыслено. Ведь в std::map ключи элементов как раз-таки сравниваются

...
E>    int    opCmp( Compound_Key o )
E>    {
E>        if( a_ < o.a_ || ( a_ == o.a_ && b_ < o.b_ ) )
E>            return -1;
E>        // Оптимистично предполагаем, что всегда будет использоваться (c1<c2).
E>        return 0;
E>    }
...

byte[100] array; // будут инициализированны по умолчанию.

void foo(out int bar)
{
}
    int bar = 3;
    foo(bar);
//    bar is now 0

ЗХ>//D
ЗХ>A a, b;
ЗХ>if(a == b)    ...            //вызов A.opEquals
ЗХ>if(a != b)    ...            //вызов !A.opEquals
ЗХ>

int opCmp(T a, T b) 
{ 
   if(a < b) return -1;
   if(a > b) return 1;
   return 0;
}

CS>typedef uint Color; 
CS>Color c; 
CS>c += 28; // ошибка компиляции.
CS>

typedef Color = ....;
// или
type Color = ...;

MS>int opCmp(T a, T b) 
MS>{ 
MS>   if(a < b) return -1;
MS>   if(a > b) return 1;
MS>   return 0;
MS>}
MS>

//это - С++
//надо определить:

bool operator==(A&);
bool operator< (A&);

//сами сгенерятся:
bool operator!=(A&);    //!operator==
bool operator>=(A&);    //!operator<
bool operator<=(A&);    //operator== || operator<
bool operator> (A&);    //!operator<=

CS>>typedef uint Color; 
CS>>

LCR>typedef Color = ....;
LCR>// или
LCR>type Color = ...;
LCR>

LCR>Ы?

int c;    //переменная типа int
typedef int mycoolint;    //тип "типа" int

Dim VBAForeva As Rulezzzz;

int v = a*b/c;

v = a.muldiv(b, c);
или 
v = a.mulshift(b, 32); // - умножаем и берем старшие 32 бита

int lift = a/b;
int rem  = a%b;

class Task
{
    private int priority;
    public int opCmp(Task t)
    {
        return priority - t.priority;
    }
}

ЗХ>int c;    //переменная типа int
ЗХ>typedef int mycoolint;    //тип "типа" int
ME>typedef int (*mcfp[](int (*fp)(void* v1, void* v2), int& r);
ME>struct S {....};
ME>struct _tagS {....} S1; // определение типа S1!
ME>class C {...};
ME>enum E {...};
ЗХ>

ЗХ>Dim VBAForeva As Rulezzzz;
ЗХ>

type ocaml_owns_all =
  Val of int
  | Fun of (float->string) * ocaml_owns_all;;

type mcfp = array of
(
  func * : ( (func * : (void *, void *) -> int ), void * ) -> int
);

typedef int *myarr1[];
typedef int (*myarr2)[];

CS>typedef uint Color; 
CS>Color c; 
CS>c += 28; // ошибка компиляции.
CS>

class IdealInt : public int
{
 //...
};

class Constructors: Base
{
    int a;

    this();            //конструктор всегда зовут this. Что облегчает использование паттерна проектирования copy-paste :)
    this(int i)     //как и в C++, конструкторов может быть несколько, они могут принимать параметры
    {
        a = i;        //инициализация членов - просто в теле конструктора
        this();        //в отличие от С++, конструкторы могут вызывать друг друга.
        
        super(10);    //вызов конструкторов базового класса - в любом месте конструктора. если нет явного вызова, вызовется в самом начале this(
    }
    
    int b = 18;        //инициализация членов константами
    
    ~this()            //с деструктором тоже все банально - он один, без параметров, всегда виртуальный
    {
    }
};

class A
{
    int r = random();       //так нельзя!
    
    static this()
    {
        //это выполнится до начала main 1 раз. выделение ресурсов, задание начальных значений данных членов...
        r = random();       //а вот так - можно!
    }
    
    static ~this()
    {
        //выполнится после конца main
    }
}

class Resource
{
    Resource()
    {
    /*
        открываем файлы, создаем сокеты и вообще творим всякие непотребства
    */
    }
    
    ~Resource()
    {
    //убираем за собой
    }
}

//где-то в коде:
{
    Resource r;    //взяли ресурс
    
    ....
} //ресурс освободился - даже в случае исключения

auto class Resource        //весь фокус - тут
{
    this()
    {
    /*
        открываем файлы, создаем сокеты и вообще творим всякие непотребства
    */
    }
    
    ~this()
    {
    //убираем за собой
    }
}

//где-то в коде:
{
    Resource r = new Resource;       //так авто-классы использовать нельзя
    auto Resource r =  new Resource; //только с явным указанием намерений
    
    ....
} //при выходе из scope - вызовутся деструкторы всех auto-переменных, ресурсы освободятся - даже в случае исключения

ЗХ>class A
ЗХ>{
ЗХ>    int r = random();       //так нельзя!
    
ЗХ>    static this()
ЗХ>    {
ЗХ>        //это выполнится до начала main 1 раз. выделение ресурсов, задание начальных значений данных членов...
ЗХ>        r = random();       //а вот так - можно!
ЗХ>    }
    
ЗХ>    static ~this()
ЗХ>    {
ЗХ>        //выполнится после конца main
ЗХ>    }
ЗХ>}
ЗХ>

extern (C) void gc_init();
extern (C) void gc_term();
extern (C) void _minit();
extern (C) void _moduleCtor();
extern (C) void _moduleUnitTests();

extern (Windows)
int WinMain(HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPSTR lpCmdLine,
    int nCmdShow)
{
    int result = 0;

    gc_init();          // initialize garbage collector
    _minit();           // initialize module constructor table

    try
    {
      _moduleCtor();      // call module constructors
      _moduleUnitTests(); // run unit tests (optional)
    }
    catch (Object o)        // catch any uncaught exceptions
    {
      // failed [code skiped]....  
      result = -2;
    }

    if( result == 0 )
    {
      try 
      {
        NativeApplication.initialize();
        // main message pump loop
        while( true ) 
        {
          if(!NativeApplication.doEvents())
            break;
        }
        result = 0; 
      }
      
      catch (Object o)        // catch any uncaught exceptions
      {
        result = -1;     // failed
        // [code skiped]
      } 
      finally 
      {
        NativeApplication.finalize();
      }
    }

    gc_term();          // run finalizers; terminate garbage collector
    return result;
}

• Есть 2 точки деструкции объекта: когда его можно удалить (например, на объект есть единственная ссылка, и она выходит из зоны видимости), и когда объект действительно удаляется. Желательно иметь возможность написать свой код для обоих случаев. (auto — это да, а ещё?)
  
• Можно ли вызывать виртуальные функции в конструкторах и деструкторах?

MS>int v = a*b/c;
MS>

MS>v = a.muldiv(b, c);
MS>или 
MS>v = a.mulshift(b, 32); // - умножаем и берем старшие 32 бита
MS>

MS>int lift = a/b;
MS>int rem  = a%b;
MS>

struct MulResult
 {
  int hi;
  unsigned int low;
  
  operator int() const { return low; }
 };
 
builtin MulResult operator * (int a,int b);

C>void foo(out int bar)
C>{
C>}
C>    int bar = 3;
C>    foo(bar);
C>//    bar is now 0

    //======================================================comp_op_table_rgba
    template<class ColorT, class Order> struct comp_op_table_rgba
    {
        typedef typename ColorT::value_type value_type;
        typedef void (*comp_op_func_type)(value_type* p, 
                                          unsigned cr, 
                                          unsigned cg, 
                                          unsigned cb,
                                          unsigned alpha);
        static comp_op_func_type g_comp_op_func[];
    };

    //==========================================================g_comp_op_func
    template<class ColorT, class Order> 
    typename comp_op_table_rgba<ColorT, Order>::comp_op_func_type
    comp_op_table_rgba<ColorT, Order>::g_comp_op_func[] = 
    {
        comp_op_rgba_clear<ColorT,Order>::blend_pix,
        . . .
    };

CS>>typedef uint Color; 
CS>>Color c; 
CS>>c += 28; // ошибка компиляции.
CS>>

WM>class IdealInt : public int
WM>{
WM> //...
WM>};
WM>

alias char[] string; 
void insert(inout string s, uint pos, string what) // external method of string
{ 
  //.... 
}

//Вызов 

string s;
s.insert(1,"something");

E>class    Compound_Key
E>{
E>    int    opCmp( Compound_Key o )
E>    {
E>        if( a_ < o.a_ || ( a_ == o.a_ && b_ < o.b_ ) )
E>            return -1;
E>        // Оптимистично предполагаем, что всегда будет использоваться (c1<c2).
E>        return 0;
E>    }
E>};
E>

class    Compound_Key
{
    int    opCmp( Compound_Key o )
    { int Result;
        Result =a_.opCmp(o.a_);
        if (Result!=0) return Result;
        Result =b_.opCmp(o.b_);
        if (Result!=0) return Result; // и продолжить столько раз, сколько полей
        Result =c_.opCmp(o.c_);
        return Result;
    }
};

class Task
{
    static const MaxPriority = // ...;
    static const MinPriority = // ...;

    public this(int priority_)
    {
        priority = priority_;
    }

    public opCmp(Task t)
    {
        priority - t.priority;
    }

    invariant
    {
        assert((priority >= MinPriority) && (priority <= MaxPriority));
    }

    private int priority;
}

std::pair<int,int> divmod(int a, int b)
{
    std::make_pair(a / b, a % b);
}

divmod a b = (a / b, a % b)

divmod(a,b) { (a / b, a % b) }

template <class T>
std::pair<T,T> divmod(T a, T b)
{
    std::make_pair(a / b, a % b);
}

 ЗХ>> int c; //переменная типа int
 ЗХ>> typedef int mycoolint; //тип "типа" int
 L> ME>typedef int (*mcfp[](int (*fp)(void* v1, void* v2), int& r);


Тут ашипка - скобочки не хватает. Надо  typedef int (*mcfp[])(int 
(*fp)(void* v1, void* v2), int& r);
"Аналогия" никуда не делась. Вполне можно написать
[ccode]
int foo(int (*fp)(void* v1, void* v2), int& r)
{
return 20;
}
int bar(int (*fp)(void* v1, void* v2), int& r)
{
return 20;
}
int (*mcfp[])(int (*fp)(void* v1, void* v2), int& r) = {foo, bar, 0};
[/ccode]

 L> ME>struct S {....};
 L> ME>struct _tagS {....} S1; // определение типа S1!
 L> ME>class C {...};
 L> ME>enum E {...};
 ЗХ>>

simpledeclaration:
    declspecifierseq opt    initdeclaratorlist opt;

typedef int (*mcfp[])(int (*fp)(void* v1, void* v2), int& r);

typedef int (*mcfp)(int (*fp)(void* v1, void* v2), int& r) [];
typedef int (*mcfp)[](int (*fp)(void* v1, void* v2), int& r);
typedef int [] (*mcfp)(int (*fp)(void* v1, void* v2), int& r);

type mcfp = .. /* anything you want */;

MS>int v = a*b/c;
MS>

MS>v = a.muldiv(b, c);
MS>или 
MS>v = a.mulshift(b, 32); // - умножаем и берем старшие 32 бита
MS>

(* / ) типа как ( ? : )

MS>int lift = a/b;
MS>int rem  = a%b;
MS>

c % o = d1 \ d2;
или
(c % o) = d1 \ d2;

a) непротиворечивости с традиционными
б) легкости разбора
с) а кто будет ими пользоваться?

CS>Да, МcSeem?

    MyObject o = new MyObject (200);
    delete o;
    o.method();    // segmentation fault

    printf ("create an object\n");
    MyObject o = new MyObject (100);
    printf ("kill the object\n");
    delete o;
    printf ("dance on the grave %)\n");
    for (int i = 1; i <=100; i++)
        delete o; // segmentation fault

    MyObject o = ...;
    delete  o;
    // o == null
    printf ("dance on... Where is the grave?!!! %)\n");
    for (int i = 1; i <=100; i++)
        delete o; // segmentation fault

FR>>У меня прямо дежавю какое то, все как в питоне

ЗХ>забавно а как это там выглядит?

__add__(self, other)
__sub__(self, other)
__mul__(self, other)
__div__(self, other)
__mod__(self, other)
__divmod__(self, other)
__pow__(self, other [, modulo])
__lshift__(self, other)
__rshift__(self, other)
__and__(self, other)
__xor__(self, other)
__or__(self, other)

struct Mul
 {
  int hi;
  unsigned low;
    
  Mul(int a,int b);
 };

import std.perf, std.stdio, std.random;

class Task
{
    // (INT_MAX/2)
    static const int MaxPriority = 1073741823;
    // (INT_MIN/2)
    static const int MinPriority = -1073741824;

    public this(int priority_)
    {
        priority = priority_;
    }

    int opCmp(Object o)
    {
        Task t = cast (Task) o;
        return priority - t.priority;
    }

    public int Priority()
    {
        return priority;
    }

    public void Priority(int p)
    {
        priority = p;
    }

    invariant
    {
        assert((priority >= MinPriority) && (priority <= MaxPriority));
    }

    private int priority;
}


const int CHUNK_SIZE = 2000;
const int N_CYCLES = 100;

void main()
{
    HighPerformanceCounter t = new HighPerformanceCounter();
    t.start();
    Task[] tl;
    try
    {
        
        for (int i = 0; i < N_CYCLES; ++i)
        {
            for (int j = 0; j < CHUNK_SIZE; ++j)
                tl ~= new Task((rand() % (1073741823 * 2)) - 1073741824);
            tl.sort;
        }        
        // tl[0].Priority = 2147483647;
    }
    catch(Exception e)
    {
        writefln(e.msg);
    }
    t.stop();
    writefln("time elapsed : %d",t.milliseconds());
    foreach (Task t; tl)
        writefln("%d",t.Priority);
}

 L> typedef int (*mcfp)(int (*fp)(void* v1, void* v2), int& r) [];
 L> typedef int (*mcfp)[](int (*fp)(void* v1, void* v2), int& r);
 L> typedef int [] (*mcfp)(int (*fp)(void* v1, void* v2), int& r);
 L>

type mcfp = array of
(
  func : ( (func : (void , void ) -> int ), void * ) -> int
);

int (*mcfp[])(int (fp)(void v1, void* v2), int& r) = {foo, bar, 
0};

 type
 L> mcfp = .. /* anything you want */;
 L>

L> PS: у меня ещё одна ошибка была

Major Goals of D
...
* Make D substantially easier to implement a compiler for than C++.
...
* Have a context-free grammar.
...

class ArrayList { 
  void Insert(int index , object value)
     requires 0 <= index && index <= Count otherwise ArgumentOutOfRangeException;
     requires !IsReadOnly && !IsFixedSize otherwise NotSupportedException;
  { 
    ....    
  }

DMD Front End Starter Kit

The dmdfe program consists of the Digital Mars D compiler front end with the backend hooks stubbed out. The goal is to make it easy to write tools that can parse and do basic semantics analysis on D code.

uw>В D (ассерты == исключения). Просто выбрасывается исключение AssertError. Если не ловить, то работает как ассерт.

uint v1 = 0, v2 = 2;
Console.WriteLine(v1 - v2);

uw>P.S. Забавно, что все соглашаются, что может быть integer overflow и никто не обратил внимание на то, что код абсолютно не корректен(например отсутствие return в opCmp). Немножко не те языки уже начинают вырабатывать стойкие привычки.

class Base
{
    [Required]
    public Constructor()
    {
    }
}

class A : Base
{
    public Constructor()
    {
        ...
        Constructor(); // OK
        ...
    }
}

calss B
{
    public Constructor()
    {
        ...// Ошибка! Должен вызываться базовый конструктор.
    }
}

//однострочный комментарий - как в С++
/*
многострочный комментарии - тоже как в С++
*/

/+
вложенный комментарий - вот такого С++ не умеет ;)
 /+
   это вложено
 +/
тут - все еще комментарий
+/

//C++
123456789.123456789       //сколько-сколько?

//D
123_456_789.123_456_789   //внутренние подчеркивания игнорируются

//C++
//модификаторы доступа:
class A
{
public:
//ниже пошли паблики
....

private:
//ниже пошли приваты
....
}

static int boo();

const int a;

//D - свобода выбора======================

class A
{
public:
//ниже пошли паблики
....

protected int foo();    //protected относится только к этой функции

    private
    {
       //private относится ко всему, что в этом блоке
      ....
    }
}

static int boo();//одна статическая функция

static
{
//блок статических функций
}

static:
//все, ниже пошли статики...

//с const и вообще всеми модификаторами - аналогичная фигня:

const int a;

const
{
//куча констант
}

const:
//дальше все нафик константное

//Выравнивание:
align(1) char some_byte;
align(4)
{
    //all here is aligned by 4
}

//deprecated:
deprecated
{
    int foo();
    void boo();
    
/*
  таким аттрибутом можно пометить части библиотеки, которые могут быть
  удалены в следующих релизах. Реакция на этот аттрибут зависит от оп-
  ций компилятора. Его можно настроить так, чтобы он выдавал предупре-
  ждение, ошибку или молчал на использование deprecated фич.
*/
}

//override
class A
{
   override int foo(); //эта функция обязана быть у моего предка (я хочу заместить функцию предка.
                       //если ее там нет или у нее другой набор параметров - это ошибка
}

kaboom:
for(...)
{
    while(...)
    {
        do
        {
            break kaboom;
        }while(...)
        continue kaboom;
    }
}

//Гарантируется, что вот такой массив:
int[3][6] Matrix;
//- то есть статический массив статических массивов
//хранится в памяти как матрица, то есть все значения идут подряд.

//C++:
char path[] = "c:\\My documents\\something\\else"; //not good
char regex[]= "[^\\\\]*(\\\\.[^\\\\]*)*";       //brrrrrrrr!

//D:
char path[] = r"c:\My documents\something\else"; //:)
char regex[]= `[^\\]*(\\.[^\\]*)*`;              //another way :)

//Инициализация структур:
struct S
{
   int a;
   char b;
   float f;
}

S s = {5, 'a', 0.3}; //можно - как в С++
S s = {b:'a'};       //явная инициализация члена b, остальные проинициализируются по умолчанию

//Инициализация массивов:
int[10] arr1 = {0,1,2,3,4,5,6,7,8,9};    //как в С++

int[10] arr2 = {1:18, 6:10, 9:-1};       //теперь содержимое arr2 == {0, 18, 0, 0, 0, 0, 10, 0, 0 ,-1}

ЗХ>//Инициализация массивов:
ЗХ>int[10] arr1 = {0,1,2,3,4,5,6,7,8,9};    //как в С++

ЗХ>int[10] arr2 = {1:18, 6:10, 9:-1};       //теперь содержимое arr2 == {0, 18, 0, 0, 0, 0, 10, 0, 0 ,-1}
ЗХ>

//Инициализация массивов:
int[10] arr1 = [0,1,2,3,4,5,6,7,8,9];    //как в С++
int[10] arr2 = [1:18, 6:10, 9:-1];       //теперь содержимое arr2 == {0, 18, 0, 0, 0, 0, 10, 0, 0 ,-1}