• Saurabh Das (14/14) Feb 04 2021 This code:
• tsbockman (84/98) Feb 04 2021 `Rebindable!(C).toHash` forwards to `C.toHash`, which is
• Saurabh Das (6/9) Feb 17 2021 This solved my issue. I finally understood why this was happening

Saurabh Das <saurabh.das gmail.com> writes:

This code:

void main()
{
     import std.typecons : rebindable, tuple;
     const c = new C();
     auto t = tuple(c.rebindable);
}

class C
{
}

When compiled with DMD 2.095.0 gives a warning:

Warning: struct Rebindable has method toHash, however it cannot 
be called with const(Rebindable!(const(C))) this.

What is causing this? How can this warning be resolved?

tsbockman <thomas.bockman gmail.com> writes:

On Thursday, 4 February 2021 at 08:16:06 UTC, Saurabh Das wrote:
 This code:

 void main()
 {
     import std.typecons : rebindable, tuple;
     const c = new C();
     auto t = tuple(c.rebindable);
 }

 class C
 {
 }

 When compiled with DMD 2.095.0 gives a warning:

 Warning: struct Rebindable has method toHash, however it cannot 
 be called with const(Rebindable!(const(C))) this.

 What is causing this? How can this warning be resolved?

`Rebindable!(C).toHash` forwards to `C.toHash`, which is 
inherited from `Object.toHash`, which has the type: `nothrow 
 trusted ulong()` according to pragma(msg, 
typeof(Object.toHash));` That type signature forbids calling 
`Object.toHash` on a mutable object. (An example of why this 
might be a valid design choice, would be if computing the hash is 
expensive and so the result is cached, which requires the freedom 
to mutate the instance.)

To fix this problem, you need to do at least one of the following:

1) Make `c` mutable by declaring it with `auto` or `C` instead of 
`const`. This is the only option if you cannot change the 
definition of `C`.

2) If you can change `C`, you can override `toHash` in `C` with a 
signature and implementation that do not require a mutable 
object. Examples:

     A) If you don't need associative array support from `C` or 
its descendants at all, simply define `C.toHash` with more 
permissive (to the caller) attributes, and crash if it gets 
called unexpectedly:

class C
{
     override size_t toHash() scope const pure  safe nothrow  nogc
     {
         assert(0, "Not implemented!");
     }
}

     B) If you want to support associative arrays by treating 
every instance of `C` as a unique value:

class C
{
     override size_t toHash() scope const pure  safe nothrow  nogc
     {
         static assert(C.sizeof == size_t.sizeof);
         union Bits
         {
             const(C) self;
             const(size_t) hash;
         }
		return Bits(this).hash;
     }

     // opEquals must always be defined such that is consistent 
with toHash, such that this passes:
     // if(this.opEquals(that))
     //     assert(this.toHash() == that.toHash());
     override bool opEquals(Object that) scope const pure  safe 
nothrow  nogc
     {
         return (this is that);
     }
     bool opEquals(scope const(C) that) scope const pure  safe 
nothrow  nogc
     {
         return (this is that);
     }
}

     C) If you want to support associative arrays by treating 
separate instances of `C` as equal based on the contents of their 
data fields, then you will need to define appropriate `toHash` 
and `opEquals` implementations:

class Point
{
     int x, y;

     override size_t toHash() scope const pure  safe nothrow  nogc
     {
         return size_t(x) * size_t(y);
     }

     override bool opEquals(Object that) scope const pure  safe 
nothrow  nogc
     {
         if(auto thatPoint = cast(Point) that)
             return opEquals(thatPoint);
         else
             return false;
     }
     bool opEquals(scope const(Point) that) scope const pure  safe 
nothrow  nogc
     {
         return (this.x == that.x) && (this.y == that.y);
     }
}

TLDR; Either make `c` mutable, or override/overload the `C` 
associative array support methods `toHash` and `opEquals` to 
support `const(C)` objects.

Saurabh Das <saurabh.das gmail.com> writes:

On Thursday, 4 February 2021 at 20:40:43 UTC, tsbockman wrote:
 TLDR; Either make `c` mutable, or override/overload the `C` 
 associative array support methods `toHash` and `opEquals` to 
 support `const(C)` objects.

This solved my issue. I finally understood why this was happening 
after digging in to the tuple code and hence understood your 
proposed solutions.

Thank you so much! :)

Saurabh