Спасаясь от «Inout ад»

Question

У меня есть очень простой код, который отказывается компилировать:

struct Wrapper(T) 
{ 
    T t; 

    bool opEquals(inout(Wrapper) other) inout 
    { 
     return t == other.t; 
    } 

    bool opEquals(inout(T) val) inout 
    { 
     return t == val; 
    } 
} 

struct Test 
{ 
    bool opEquals(Test t) 
    { 
     return true; 
    } 
} 

void main() 
{ 
    Wrapper!Test a, b; 

    assert(a == b); 

    //Error: inout method Test.opEquals is not 
    //callable using a mutable object 
    assert(a == Test()); 
} 

Теперь, я знаю эту проблему, которая является то, что Test не определен inoutopEquals. Однако определение другой изменчивой версии opEquals в Test не устраняет эту проблему, поскольку компилятор просто игнорирует ее и вызывает версию inout независимо. Есть ли способ решить эту проблему, не прибегая к определению перегрузки opEquals для изменчивого, const и immutable?

Answer 1

Все inout предназначено для того, чтобы константа возвращаемого типа могла соответствовать константе аргумента функции. Если у вас есть

const(Foo) bar(const(Foo) f) { 
{ 
    //... 
    return f; 
} 

и вы передаете mutable или immutable объект bar, вы в конечном итоге с const возвращаемый объект, в то время как при использовании inout

inout(Foo) bar(inout(Foo) f) { 
{ 
    //... 
    return f; 
} 

возвращаемый тип имеет тот же константность как аргумент передан f. В любом случае, в пределах функции, f эффективно обрабатывается как const. Вы можете только называть const и inout функциями. Таким образом, создание opEqualsinout бессмысленно, потому что оно не возвращает никаких аргументов. Это то же самое, что и делать это const.

Ваша основная проблема заключается в том, что вы пытаетесь вызвать изменяемую функцию на объекте const. И это не законно, потому что это нарушает const. У вас есть один из двух вариантов:

1. Марка Wrapper «ы opEquals изменяемых. Затем он может позвонить opEquals, когда T's opEquals изменен.

2. Использование static if определить opEquals по-разному в зависимости от того, как T определяется opEquals.

Там нет никакого способа, чтобы направить константность opEquals от T к Wrapper, не делая его явно с static if. например

struct Wrapper(T) 
{ 
    T t; 

    static if(is(typeof({const T t; t == t;}))) 
    { 
     bool opEquals(const Wrapper other) const 
     { 
      return t == other.t; 
     } 

     bool opEquals(const T val) const 
     { 
      return t == val; 
     } 
    } 
    else 
    { 
     bool opEquals(Wrapper other) 
     { 
      return t == other.t; 
     } 

     bool opEquals(T val) 
     { 
      return t == val; 
     } 
    } 
} 

Поскольку Wrapper шаблон, pure, nothrow и @safe будет выведено на его функции, но нет никакого логического вывода атрибут const, inout или immutable.

Answer 2

Просто удалите inout. Компилятор автоматически передает атрибуты, такие как const для шаблонов.

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

Обратите внимание, что поскольку в вашем примере Test.opEquals не является const, его можно вызвать только на изменяемый объект. Также обратите внимание, что в D const транзитивен, поэтому const(Wrapper!Test) такой же, как const(Wrapper!(const(Test))). Поэтому, несмотря ни на что, вы не можете вызвать Test.opEquals на объект const/immutable (даже в обертке), если вы не сделаете его const.