Today, while playingly adding const annotations to std.bigint, I noticed that I ended up with a few casts - or more specifically, assumeUniques.

Now, the interesting thing was the pattern they formed. Almost invariably, it's like this:
    BigUint foo() pure {
        uint[] result;
        //...
        return BigUint(assumeUnique(result));
    }

Now, had I instead returned uint[] directly, an external function could take advantage of the fact that the function was pure:

    uint[] fooImpl() pure {
        uint[] result;
        //...
        return result;
    }

    BigUint foo() pure {
        return BigUint(fooImpl());
    }

As one can clearly see, this removes the need for assumeUnique. However, it also complicates the design. Lastly, given that the compiler already knows the return value of a pure function is magical, it seems it should be possible to exploit that also here.

I will therefore suggest that when the return statement of a pure function consists of a single call to another pure function, and there is no possibility of aliasing of arguments, the arguments to that call may be treated as immutable.

Destroy.

--
  Simen

On Friday, 1 November 2013 at 18:12:28 UTC, Simen Kjaeraas wrote:
> Today, while playingly adding const annotations to std.bigint, I noticed that I ended up with a few casts - or more specifically, assumeUniques.
>
> Now, the interesting thing was the pattern they formed. Almost invariably, it's like this:
>     BigUint foo() pure {
>         uint[] result;
>         //...
>         return BigUint(assumeUnique(result));
>     }
>
> Now, had I instead returned uint[] directly, an external function could take advantage of the fact that the function was pure:
>
>     uint[] fooImpl() pure {
>         uint[] result;
>         //...
>         return result;
>     }
>
>     BigUint foo() pure {
>         return BigUint(fooImpl());
>     }
>
> As one can clearly see, this removes the need for assumeUnique. However, it also complicates the design. Lastly, given that the compiler already knows the return value of a pure function is magical, it seems it should be possible to exploit that also here.
>
> I will therefore suggest that when the return statement of a pure function consists of a single call to another pure function, and there is no possibility of aliasing of arguments, the arguments to that call may be treated as immutable.
>
> Destroy.
>
> --
>   Simen

isolated. I think that will become my answer to most problem as of now :D