func() : (a:int * b:int * color:int)
{
  def x = new { a = 5, b = 20, color=30 };//тут по пальцам если вместо a и b указаны x и y, идеально если ещё и порядок не важен
  x;
}

//использование
def r = func();

Console.WriteLine(r.a);
Console.WriteLine(r.b);
Console.WriteLine(r.color);

type Idx = int;
type Idy = int;
type Idz = int;

//объявление двумерного ступенчатого массива, с индексаторами Idx, Idy и типом значения Idz
def a : array[(dimension1 : Idx) array[(dimension2 : Idy) Idz]];

//тут компилятор даст по пальцам, т.к. у массива типы не int
a[5][10] = 20; 
//тут ок, т.к. у массива индексаторы правильных типов, и значение тоже правильного типа
a[5:Idx][10:Idy] = 20:Idz;

def iX = 1 : Idx;
def iY = 2 : Idy;
//с этого момента iX и iY - самостоятельные типы, 
//которые к int приводятся только через операторы : и :>
//соответственно встроенные операторы сложения вычитания и т.п. 
//тоже начинают понимать только значения правильного типа

Console.WriteLine(a[iX][iX]);//ошибка компиляции, второй индекс должен быть типа Idx;
Console.WriteLine(a[iX][iY]);//всё ок

def d : Dictionary[ItemDatabaseCode : int, ItemName : string] = Dictionary();

def d = obj : dynamic<IList>;
d.|/* <- тут автокомплит показывает методы и свойства IList, 
есть проверка синтаксиса, аргументов, и т.п. При этом компилятор ругается на попытки 
сделать что-то за пределами IList. Но это не кастинг, вызовы идут обычным 
механизмом динамиков, т.е. obj вполне может от всего IList поддерживать только Count.*/

WH>Это касается как функциональности так и оптимизаций (я знаю как сделать его еще быстрее ).

_>Имхо логично сделать сначала медленный парсер, но чтоб его начали прикручивать к Н2 пораньше, а ускорять уже в процессе. Но, полагаю, ты это и без меня прекрасно знаешь

      letterCharacter       = [Lu, Ll, Lt, Lm, Lo, Nl];
      combiningCharacter    = [Mn, Mc];
      decimalDigitCharacter = [Nd];
      connectingCharacter   = [Pc];
      formattingCharacter   = [Cf];

      identifierStartCharacter  = letterCharacter / "_";
      identifierPartCharacters  = letterCharacter / decimalDigitCharacter / connectingCharacter / combiningCharacter / formattingCharacter;
      identifierBody            = identifierStartCharacter identifierPartCharacters*;

      identifierStartCharacter  = [hint: 'a'..'z' + 'A'..'Z' + '_'] (letterCharacter / "_");
      identifierPartCharacters  = [hint: 'a'..'z' + 'A'..'Z' + '_' + '0'..'9'] (letterCharacter / decimalDigitCharacter / connectingCharacter / combiningCharacter / formattingCharacter);

_>func() : (a:int * b:int * color:int)
_>{
_>  def x = new { a = 5, b = 20, color=30 };//тут по пальцам если вместо a и b указаны x и y, идеально если ещё и порядок не важен
_>  x;
_>}

_>//использование
_>def r = func();

_>Console.WriteLine(r.a);
_>Console.WriteLine(r.b);
_>Console.WriteLine(r.color);
_>

[Record]
class R
{
  public A     : int { get; }
  public B     : int { get; }
  public Color : int { get; }
}

def f() : R
{
  def x = R(a = 5, b = 20, color = 30);
  x
}

[assembly: DefineRecord(A : int, B : int, Color : int)]

def func() { (1,2,3) }

def (a, b, color) = func;

[CreateType(FRet, a : int, b : int)]
public F() : FRet
{
  def x = FRet(a = 1, b = 2);
  x
}

_>//тут компилятор даст по пальцам, т.к. у массива типы не int
_>a[5][10] = 20; 
_>//тут ок, т.к. у массива индексаторы правильных типов, и значение тоже правильного типа
_>a[5:Idx][10:Idy] = 20:Idz;

      def l = MyList.[int,int]();
      l[0] = 5;
      
      def l = MyList.[Idx,int](); // Тут почему то дает ошибку: Error: expected int+, got Nemrrrr.Idx in generic specifier: Nemrrrr.Idx is not a subtype of System.Int32 [simple require]
      l[0 :> Idx] = 5;   // если  убрать where Tindex : int  то эта строчка работает

  enum Idx : int {}
  
  class MyList[Tindex,Tval]
    where Tindex : int
  {
    _l : List[Tval] = List();
    
    public Item[index : Tindex] : Tval
    {
      get
      {
        _l[index]
      }
      set
      {
        _l[index] = value;
      }
    }    
  }

[ExpandToRecord]
Func(a : int, b : bool, out c : int, out m : decimal) : void
{
//здесь компилятор искаропки проследит чтобы возвращаемые значения были правильно заданы, и т.п.
}

//а аттрибут создаёт пару типов AB и CM, и различные версии функции, которые вызывают основную
Func(ab : AB) : CM
{  
  def cm = CM();
  Func(ab.a, ab.b, out cm.c, out cm.m);
  cm;
}

Func(ab : AB, out c : int, out m : decimal) : void
{ 
}

Func(a : int, b : bool) : CM
{
}

  public enum Idx : int {}
  
  public class MyList[Tindex,Tval]
    where Tindex : ValueType

  {
    static this()
    {
      def typ = typeof(Tindex); 
      unless (typ.Equals(typeof(int)) || typ.IsEnum)
        throw System.ArgumentException();
    }    
    
    _l : array[Tval];
    public this(size : int)
    {
      _l = array(size);
    }
    
    public Item[index : Tindex] : Tval
    {
      get
      {
        _l[index :> int]
      }
      set
      {
        _l[index :> int] = value;
      }
    }    
  }

      def l = MyList.[int,int](5);
      l[0] = 5;
      
      def l = MyList.[Idx,int](5);
      l[1 :> Idx] = 5;
      
      def l = MyList.[double,int](5); // тут будет Ексепшн, что тип  недопустим

_>type Idx = int;
_>type Idy = int;
_>type Idz = int;
_>

strong type Idx = int;

class Idx
{
  _value : int;

  public this() { }
  public this(value : int) { _value = value; }

  public static @:(o : Idx) : int { _value; }

  ... // Тут уже надо думать что и как делать
}

[return: RecordInfo("Id Name Birthday")]
SomeMethod(person : Record[Id : int, Name : string, Birthday : DateTime]) : Record[Id : int, Name : string, Birthday : DateTime]
{
  person
}

[return: RecordInfo("Id Name Birthday")]
SomeMethod([RecordInfo("Id Name Birthday")] person : int * string * DateTime) : int * string * DateTime
{
  ...
}

def person = SomeMethod(Record(Id=42, Name="Вася", Birthday=DateTime(1974, 4, 25)));

WriteLine($"Идентификатор: $(person.Id) Имя: $(person.Name) Дата рождения: $(person.Name)");

def (Id, Name, Birthday) = SomeMethod((42, "Вася", DateTime(1974, 4, 25)));

WriteLine($"Идентификатор: $Id Имя: $Name Дата рождения: $Name");

ВВ>Впрочем, возникает подозрение, что это немало работы