equivariant functions

[Andrei Alexandrescu]

Steven Schveighoffer wrote:
> "Andrei Alexandrescu" wrote
> I'm glad you are looking into this.  This is along the same vein as what I 
> called 'scoped const' (see 
> http://d.puremagic.com/issues/show_bug.cgi?id=1961), but I only addressed 
> const variance.
> 
> Just in terms of const, I have a case where your solution doesn't help/work.
> 
> Easiest case is min/max:
> 
> typeof(v1) min(T)(const(T) v1, const(T) v2) { if(v1 < v2) return v1; return 
> v2;}
> 
> Now, imagine you call it like this:
> 
> char[] best = "bb".dup;
> best = min(aa, "aa");
> 
> If the function and usage are allowed to compile, then this results in best, 
> being a char[], to be pointing to an invariant(char)[].

The function doesn't compile per the typechecking I discussed in a 
different post.

> There are two problems that need to be solved here.  First, you need another 
> const type.  One that is treated as const, but is implicitly castable back 
> to the argument type, and can't be implicitly casted to.  That type modifier 
> needs to be perpetuated throughout the function, because you shouldn't be 
> able to return things that didn't originate from the input.  If I create a 
> temporary variable, I should have to use this modifier to declare the 
> variable (in my proposal, at the suggestion of Janice, I used 'inout', a 
> dead keyword).  This guarantees that your output is a subset of the input.

I think the typedef-based approach could work (and be that type you 
mention).

> An example of how min looks in my proposal (with the proposed 'inout' 
> keyword):
> 
> inout(T) min(T)(inout(T) v1, inout(T) v2)
> 
> The second problem is, you want the return type to be dependent on both v1 
> and v2.  In my proposal, the return type could depend on multiple arguments, 
> and if they varied by constancy, the return type was defaulted to const, as 
> this is the only possible type that anything can be casted to.
> 
> You might be tempted to do something like this:
> 
> typeof(v1) min(T)(const(T) v1, typeof(v1) v2)
> 
> But then if you pass in the mutable version as the first, the function fails 
> to compile in the usage I have above.

My solution does theoretically support multiple types by including them 
in the typeof expression. Walter, however, mentioned potential 
difficulties with implementing them.


Andrei