DIP30, delegates more destruction for your pleasure

[Timon Gehr]

On 03/14/2013 04:12 AM, deadalnix wrote:
> ...
>>
>
> It is a tempting idea, but do not work. Consider :
>
> void delegate() immutable a;
> const void delegate() b = a;
>
> This would be forbidden as covariance of function parameters and
> transitivity act in opposite directions.

Uh, why?

In my current opinion, it should be as follows:

void main(){
	void delegate()inout w;
	void delegate()immutable i;
	void delegate()const c;
	void delegate() m;
	void delegate()const inout wc;
	
	// The following cases should be disallowed:
	
	i=c; // there may be mutable references to context
	c=m; // m may modify context
	i=m; // m may modify context
	w=i; // cannot use immutable as const or mutable
	w=m; // cannot use mutable as immutable
	w=c; // cannot use const as immutable
	wc=m;// cannot use mutable as immutable
	wc=c;// wc will access context as const or immutable
	i=w; // inout could mean const or mutable
	c=w; // inout could mean mutable
	i=wc; // inout const could mean const

	// These should be allowed:
	
	c=i; // certainly const if only immutable data accessed
	c=wc;// certainly const if only const inout data accessed
	m=c; // just loses guarantees to caller
	m=i; // ditto
	m=w; // ditto
	m=wc;// ditto
	w=wc;// m=c, c=c and i=i are valid
	wc=i;// c=i and i=i are valid
	wc=w;// c=m is not valid, but does the same thing as c=c here
}

If you disagree with one of them, please demonstrate how to break the 
type system using the conversion, or argue why a conversion would be valid.