Inout unclearness

[Steven Schveighoffer via Digitalmars-d]

On 7/12/15 1:03 AM, Max Klimov wrote:
> inout(A) bar(inout(A) x) // compilation error
> {
>      Rebindable!(typeof(return)) r;
>      r = x;
>      return r;
> }
>
> Rebindable doesn't handle the case of inout type and I don't think that
> it can do it because it is possible to cast to inout or to keep inout
> variables only inside the proper inout function.

So a variable cannot be inout in a struct, because once it leaves the 
function, it's not clear how to cast that part of the struct to 
something else. In other words, a struct like this:

struct X(T)
{
   T t;
}

X!(int) x1;
X!(const(int)) x2 = x1;

Techincally, the assignment should be allowed, but the compiler cannot 
see into the template to see if it's actually the same, or even if the 
template parameter applies to anything in the struct. One can do 
something like:

struct X(T)
{
    static if(is(T == const))
      bool screwup;
    T t;
}

With inout, it's even more tricky, because the compiler has to ensure 
it's not inout when it leaves the function. And it's not possible in 
some cases to do this.

At the end of the day, this comes down to D not supporting tail-const 
classes. If that was supported in the language, this is all doable.

> So, I have to make some
> silly workarounds with castings in this case. The same situation happens
> in several places in phobos when arguments type is deductible. For
> example, std.array.replaceInPlace(...), std.array.join(...), etc, can
> not be used with inout(T) parameters.

Right, this is because it uses generated structs internally.

> The second question: if I want to provide inout function but it fails
> like in the example above, what is common practice? Just use casting? Or
> make a templated version and provide hand-writing code for all cases
> (mutable, const, immutable)? Or something wrong with inout qualifier?

You can simply use a template function without hand-written cases. This 
is what inout was meant to replace.

In your example:

T bar(T)(T t) if(is(Unqual!T : A))
{
    // same implementation
}

Of course, this doesn't work for inout!A as a parameter, if that is what 
you have :)

But you could specifically cast it to/from const, or do something like:

T bar(T)(T t) if(is(Unqual!T : A))
{
    static if(is(T == inout))
      return cast(T)(.bar(cast(const(Unqual!T))t));
    else
    {
        // real implementation
    }
}

-Steve