C# - Nemerle type - Nemerle

class A
{
  readonly int readonlyA = 1;
  int mutableA = 1;
  const int constA = 1;

  // static
  static readonly int staticReadonlyA = 1;
  static int staticMutableA = 1;
}

Nemerle

class A
{
  /*readonly*/ readonlyA : int = 1; // OK
  mutable mutableA : int = 1; // OK
  /*const*/ constA : int = 1; // readonly, no const

  // static
  static /*readonly*/ staticReadonlyA : int = 1; // const int !
  static mutable staticMutableA : int = 1; // OK

  static /*readonly*/ staticReadonlyB : IPAddress = IPAddress.Parse("1"); // static readonly !
}

В C# для создания констант используется const Type var, а в Nemerle static var : Type.
При чем если можно, то создается константа, а если нет то readonly.
Т.е. нельзя указать явно как в C# хотим мы const или readonly.

Нигде, вроде, это не описано.

Здравствуйте, _nn_, Вы писали:

Если не ошибаюсь чтобы получить константу нужно пометить поле модификатором static.

Здравствуйте, _nn_, Вы писали:

__>В C# для создания констант используется const Type var, а в Nemerle static var : Type.
__>При чем если можно, то создается константа, а если нет то readonly.
__>Т.е. нельзя указать явно как в C# хотим мы const или readonly.

__>Нигде, вроде, это не описано.

Да, наверно нигде. Можешь помочь родине и добавить это описание в Вики.

Здравствуйте, VladD2, Вы писали:

VD>Здравствуйте, _nn_, Вы писали:

__>>В C# для создания констант используется const Type var, а в Nemerle static var : Type.
__>>При чем если можно, то создается константа, а если нет то readonly.
__>>Т.е. нельзя указать явно как в C# хотим мы const или readonly.

__>>Нигде, вроде, это не описано.

VD>Да, наверно нигде. Можешь помочь родине и добавить это описание в Вики.
Без проблем.

http://nemerle.org/CsharpDiff

Здравствуйте, _nn_, Вы писали:

__>

__>class A
__>{
__>  readonly int readonlyA = 1;
__>  int mutableA = 1;
__>  const int constA = 1;

__>  // static
__>  static readonly int staticReadonlyA = 1;
__>  static int staticMutableA = 1;
__>}
__>

__>Nemerle
__>

__>class A
__>{
__>  /*readonly*/ readonlyA : int = 1; // OK
__>  mutable mutableA : int = 1; // OK
__>  /*const*/ constA : int = 1; // readonly, no const

__>  // static
__>  static /*readonly*/ staticReadonlyA : int = 1; // const int !
__>  static mutable staticMutableA : int = 1; // OK

__>  static /*readonly*/ staticReadonlyB : IPAddress = IPAddress.Parse("1"); // static readonly !
__>}
__>

Связанные константы нужно объявлять следующим образом:

    public module C {
        public X : short = 10s;
        public Y : short = C.X + 20s;
        public Z : short = C.X * C.Y + 7s;
    }

В этом случае все три объявления компилятор сочтет литералами и будет инлайнить их значения в местах использования (рефлектор при декомпиляции справедливо обзовет X, Y, Z константами).
Если же не писать префикс типа (C), то компилятор будет генерировать обращение к статическим полям.

Такой эффект обусловлен тем, что интерпретатор констант (ConstantFolder) для разрешения значений использует экземпляр GlobalEnv, который содержит информацию только об открытых пространствах имен без контекста текущего типа, потому и требуется полный квалификатор имени.

Еще дополню, интерпретатор констант не умеет работать с вещественными числами (float, double, decimal) и булевым типом.

Здравствуйте, hardcase, Вы писали:

H>Еще дополню, интерпретатор констант не умеет работать с вещественными числами (float, double, decimal) и булевым типом.

Прескорбно.
Nemerle:

  A1 : float = 1.0f;
  A2 : float = A1 + 2.0f;
  A3 : float = A1 + A2;
  
  B1 : double = 1.0;
  B2 : double = B1 + 2.0;
  B3 : double = B1 + B2;
  
  C1 : decimal = 1m;
  C2 : decimal = C1 + 2m;
  C3 : decimal = C1 + C2;
  
  D1 : bool = true;
  D2 : bool = true && !D1;
  D3 : bool = !D1 && !D2;

Reflector:

// Fields
private const float A1 = 1f;
private static readonly float A2;
private static readonly float A3;

private const double B1 = 1.0;
private static readonly double B2;
private static readonly double B3;

private static readonly decimal C1;
private static readonly decimal C2;
private static readonly decimal C3;

private const bool D1 = true;
private static readonly bool D2;
private static readonly bool D3;

static Program()
{
    // хм..
    A2 = 1f + 2f;
    A3 = 1f + A2;
    B2 = 1.0 + 2.0;
    B3 = 1.0 + B2;
    int[] bits = new int[4];
    bits[0] = 1;
    C1 = new decimal(bits);
    int[] numArray2 = new int[4];
    numArray2[0] = 2;
    C2 = C1 + new decimal(numArray2);
    C3 = C1 + C2;
    D2 = (1 != 0) ? (1 == 0) : false;
    D3 = (1 == 0) ? !D2 : false;
}

const float A1 = 1.0f;
const float A2 = A1 + 2.0f;
const float A3 = A1 + A2;

const double B1 = 1.0;
const double B2 = B1 + 2.0;
const double B3 = B1 + B2;

const decimal C1 = 1m;
const decimal C2 = C1 + 2m;
const decimal C3 = C1 + C2;

const bool D1 = true;
const bool D2 = true && !D1;
const bool D3 = !D1 && !D2;

Reflector

// Fields
private const float A1 = 1f;
private const float A2 = 3f;
private const float A3 = 4f;

private const double B1 = 1.0;
private const double B2 = 3.0;
private const double B3 = 4.0;

[DecimalConstant(0, 0, (uint) 0, (uint) 0, (uint) 1)]
private static readonly decimal C1;
[DecimalConstant(0, 0, (uint) 0, (uint) 0, (uint) 3)]
private static readonly decimal C2;
[DecimalConstant(0, 0, (uint) 0, (uint) 0, (uint) 4)]
private static readonly decimal C3;

private const bool D1 = true;
private const bool D2 = false;
private const bool D3 = false;

static Program()
{
    C1 = 1M;
    C2 = 3M;
    C3 = 4M;
}

Будем считать это багом ?

Здравствуйте, hardcase, Вы писали:

H>Связанные константы нужно объявлять следующим образом:
H>

H>    public module C {
H>        public X : short = 10s;
H>        public Y : short = C.X + 20s;
H>        public Z : short = C.X * C.Y + 7s;
H>    }
H>

Поравлено в r8992. Теперь свертка констант при объявлении не требует обязательного квалифицированного имени, и можно писать:

    public module C {
        public X : short = 10s;
        public Y : short = X + 20s;
        public Z : short = X * Y + 7s;
    }

Здравствуйте, _nn_, Вы писали:

__>Здравствуйте, hardcase, Вы писали:

H>>Еще дополню, интерпретатор констант не умеет работать с вещественными числами (float, double, decimal) и булевым типом.

__>Прескорбно.
__>Nemerle:
__>

__>  C1 : decimal = 1m;
__>  C2 : decimal = C1 + 2m;
__>  C3 : decimal = C1 + C2;
__>

__>Reflector:
__>

__>// Fields
__>private static readonly decimal C1;
__>private static readonly decimal C2;
__>private static readonly decimal C3;

__>static Program()
__>{
__>    // хм..
__>    int[] bits = new int[4];
__>    bits[0] = 1;
__>    C1 = new decimal(bits);
__>    int[] numArray2 = new int[4];
__>    numArray2[0] = 2;
__>    C2 = C1 + new decimal(numArray2);
__>    C3 = C1 + C2;
__>}
__>

Выбор конструктора decimal типа оттюнил в r8993, теперь константы decimal-ы изготавливаются без ~~применения оружия массового поражения~~ промежуточных массивов.

Здравствуйте, hardcase, Вы писали:

H>Поравлено в r8992. Теперь свертка констант при объявлении не требует обязательного квалифицированного имени, и можно писать:
H>

H>    public module C {
H>        public X : short = 10s;
H>        public Y : short = X + 20s;
H>        public Z : short = X * Y + 7s;
H>    }
H>

А порядок важен?
Или получилось что-то вроде ленивой инициализации?

Здравствуйте, VladD2, Вы писали:

VD>Здравствуйте, hardcase, Вы писали:

H>>Поравлено в r8992. Теперь свертка констант при объявлении не требует обязательного квалифицированного имени, и можно писать:
H>>

H>>    public module C {
H>>        public X : short = 10s;
H>>        public Y : short = X + 20s;
H>>        public Z : short = X * Y + 7s;
H>>    }
H>>

VD>А порядок важен?
VD>Или получилось что-то вроде ленивой инициализации?

Порядок по-видимому важен. Ленивости нет — это же константы. Если i-я константа не определена то будет изготовлено поле.

Здравствуйте, hardcase, Вы писали:

H>Порядок по-видимому важен. Ленивости нет — это же константы.

Это как раз не важно. Тут не ленивость нужна, а порядок определяемый ссылками.
Очень удобно если логика будет такой:

public module C
{
  public Z : short = X * Y + 7s; // Так как значения X и Y еще неизвестны, пробуем вычислить их рекурсивно.
  public X : short = 10s;
  public Y : short = X + 20s;

  public D : short = F + 20s; // Так как значение F еще неизвестны, пробуем вычислить его рекурсивно.
  public F : short = D + 20s; // Циклическая ссылка! Выдаем сообщение об ошибке и прерываем вычисление (возвращая ноль).
}

Такое поведение очень удобно, так как позволяет независимость от порядка инициализации.

H>Если i-я константа не определена то будет изготовлено поле.

Этого не понял.

От:	_nn_	www.nemerleweb.com
Дата:	27.04.10 14:20
Оценка:

От:	VladD2	www.nemerle.org
Дата:	27.04.10 14:26
Оценка:

От:	VladD2	www.nemerle.org
Дата:	27.04.10 14:28
Оценка:

От:	_nn_	www.nemerleweb.com
Дата:	03.05.10 14:30
Оценка:	96 (1)

От:	hardcase	http://nemerle.org
Дата:	27.06.10 04:54
Оценка: