Логическая константа в D

Думаю, что было бы уместно опубликовать основные выводы недавняя ветка по этой теме в группе новостей D здесь, чтобы те, кто не отслеживает этот список, могли получить соответствующий ответ.

Константа D не является логической константой. Оно транзитивно и полностью константно. Язык технически не поддерживает логическую константу. Язык не определяет способа изменения константного объекта.

И на самом деле в С++ тоже нет логической константы. Использование mutable и отбрасывание const-ness позволяет вам полностью обойти const, так что, с технической точки зрения, const на самом деле ничего не гарантирует, кроме того, что вы не вызываете никаких неконстантных функций для константной переменной. Тот факт, что константные функции на самом деле являются константными и не связаны с вашими переменными, полностью поддерживается соглашением. Теперь большинство программистов не отбрасывают константность влево и вправо и делают все изменяемым, поэтому на практике это весьма полезно, но его можно не только полностью обойти, но и язык специально дает вам определенные средства для этого. . В C++ mutable и отбрасывание const четко определены и поддерживаются языком.

Д так не делает. Константа D на самом деле константа. Отбрасывание const для переменной и последующее ее изменение не определено. Изменяемого нет. У const D есть реальные гарантии (пока вы не делаете ничего неопределенного, например, отбрасываете const на что-то, а затем мутируете). Это важно не только потому, что гарантии компилятора для D намного сильнее, чем для C++, но и потому, что неизменяемые переменные нельзя изменить каким-либо образом форму или форму. Они могут находиться в памяти только для чтения, и кто знает, какие ужасные вещи произойдут, если вы попытаетесь отказаться от неизменяемости и изменить такую ​​переменную (segfault, вероятно, будет самым приятным, что может случиться). А поскольку константная переменная на самом деле может ссылаться на неизменяемые данные, отбрасывание const для изменения переменной или разрешение каким-либо образом изменять константные переменные было бы, по меньшей мере, плохо. Так язык не позволяет.

Теперь, как указывает BCS, D является прагматичным языком. Вы можете отказаться от const, после чего вы можете изменить переменную. Так, например, у вас может быть переменная, которая использовалась для кэширования возвращаемого значения функции const (предположительно, с тем, что этот кеш становится недействительным, если состояние объекта изменилось) и отбросить const, чтобы изменить его. Пока рассматриваемая переменная на самом деле не является неизменной, она будет работать. Однако это неопределенное поведение. Как только вы это сделаете, вы сами по себе. Вы обходите систему типов и гарантии компилятора. Вы несете ответственность за то, чтобы не сделать это с неизменяемым объектом или иным образом не испортить то, что компилятор обычно гарантирует. Итак, если вам нужно это сделать, вы можете, но вы выходите на Дикий Запад, и вы должны убедиться, что вы не мутируете то, что не должны.

Учитывая, что отбрасывание const будет работать до тех пор, пока переменная на самом деле не ссылается на неизменяемые данные, можно создать шаблон Mutable, чтобы по существу получить то, что mutable дает вам в C++ (таким образом, он будет выполнять отбрасывание const -ness для вас). he_the_great приводит пример такого шаблона в своем ответе. Но использование такого шаблона по-прежнему является неопределенным поведением. Использование его на объекте, который на самом деле неизменяем, вызовет проблемы. Вы, программист, должны убедиться, что он используется правильно.

Таким образом, D технически позволяет иметь логическую константу, отбрасывая константу, но для этого вам нужно выйти за пределы того, что гарантирует компилятор, обходя систему типов, и вы должны убедиться, что не используете неправильно это и изменить переменные, которые не должны/не могут быть изменены, или ваш код будет иметь проблемы - вполне возможно, что segfaults будут наименьшими среди них.

EDIT: я забыл упомянуть об одном предложенном решении, которое не нарушает систему типов. Пока вы готовы отказаться от чистоты, вы можете использовать какую-либо глобальную переменную (будь то в области модуля, переменной класса или переменной структуры) для хранения кэшированных значений. Функция const может свободно использовать и изменять глобальные переменные, поэтому ее можно использовать вместо отсутствующей mutable. Однако это означает, что функция не может быть чистой, что также может быть большой проблемой. Однако это способ, позволяющий константной функции изменять данные, которые ей нужны, без нарушения системы типов.

Я не прикасался к D2 целую вечность, так что вы можете перепроверить то, что я говорю. :)

Я не уверен, что у вас действительно есть хорошие варианты. const и immutable в D значительно сильнее, чем в C/C++, поэтому их отбрасывание не вариант. Вы явно исключили изменение использования const в своем коде.

Вы можете кэшировать результат операции в глобальной хэш-таблице с ключом на самом значении матрицы. Это будет работать для любой комбинации const/immutable. Проблема с этим, конечно, в том, что D не имеет самых быстрых хеш-таблиц в мире, и вычисление хэша может быть медленным. Возможно, предварительно вычислить хэш при создании матрицы.

Другим вариантом было бы быстрое вычисление определителя при изменении значения.

Кроме этого, я не могу думать ни о чем другом. Проблема, на самом деле, в том, что вы просите компилятор защитить вас с помощью const, а затем пытаетесь вырваться из этого. «Правильное» решение, вероятно, просто не использовать const. :П

Будучи прагматичным языком, D может отбрасывать const, если вам это действительно нужно. Я думаю, что следующее должно работать:

class M {
  bool set;
  real val;

  real D() const {
    if(!set) {
      M m = cast(M)this;
      m.val = this.some_fn();
      m.set = true;
    }
    return this.val;
  }
}

Я настоятельно рекомендую ответ BCS, поскольку он прост и безопасен, если не создается неизменяемая/константная матрица.

Другим вариантом, который помогает сделать даже неизменяемые/константные объекты действительными, является этот изменяемый шаблон. Или, по крайней мере, это намерение. Есть комментарии по поводу беспокойства.

В этом шаблоне требуется, чтобы изменение выполнялось для типа, на который ссылаются, а не для значения в константной функции. Это означает, что используются указатели, и для каждой матрицы требуется выделить место. Это также усложняет создание неизменяемой/константной матрицы, которая не будет segfault, возможно, есть способ сделать это красиво, но я знаю только один для классов.

struct Matrix
{
    double determinant() const
    {
        if ( *m_dirty )
        {
            *m_determinant = 646.363; /* expensive calculation */;
            *m_dirty = false;
        }
        return *m_determinant;
    }

    void set(int i, int j, double x) { *m_dirty = true; }

    Mutable!(bool*) m_dirty;
    Mutable!(double*) m_determinant;
};

Чтобы имитировать логическое const из C++ в D, вы можете использовать наследование для классов:

class ConstMatrix
{
public:
    double det() { // not marked as const!
        /* ... caching code ... */
    }
    /* ... the rest of the logically const interface ... */
}

class Matrix : ConstMatrix
{
public:
    void set( int row, int col, double val ) {
        /* ... */
    }
    /* ... the non-logically const interface ... */
}

В реализации класса ConstMatrix у вас не будет никаких проверок компилятора, если вы не поместите квалификаторы const в сигнатуры функций. Однако вы получите константную корректность для клиентского кода, если будете использовать ConstMatrix для логически постоянных матриц.

Для структур вы можете использовать технику alias, чтобы сделать то же самое:

struct ConstMatrix 
{
    /* logically const bla bla blub */
}

struct Matrix
{
public:
    alias m this;

    /* non-const bla bla blub */
private:
    ConstMatrix m;
}

Для типов классов вы можете построить другие classes или structs с правильностью логической константы следующим образом:

class ConstBiggerClass
{
private:
    ConstMatrix m;
}

class BiggerClass : ConstBiggerClass
{
private:
    Matrix m;
}

Таким образом, компилятор проверит const правильность за вас. Однако вам понадобится дополнительный элемент данных. Для элементов типа class в типах class альтернативой может быть предоставление функции-члена, которая возвращает элемент данных с правильной константностью:

class ConstBiggerClass
{
public:
    void someLogicallyConstFunction( /*...*/ ) { /* ... */ }
protected:
    abstract ConstMatrix getMatrix();
}

class BiggerClass : ConstBiggerClass
{
public:
    void someMutableFunction( /*...*/ ) { /*...*/ }
protected:
    Matrix getMatrix() { return m; }
private:
    Matrix m;
}