Against enforce()

[Simen kjaeraas]

On Mon, 21 Mar 2011 15:35:58 +0100, Steven Schveighoffer  
<schveiguy at yahoo.com> wrote:

> Why does one make sense and the other not?  In other words, if I have a  
> function like this:
>
> int foo(int delegate() x) pure {...}
>
> is this *ever* callable from a strong-pure function?  Or does the  
> delegate have to be declared pure?  It seems to me that either:
>
> 1) it's not ever callable from a strong-pure function, making the pure  
> decoration useless or
> 2) it's callable from a strong pure function, but then the compiler  
> needs to generate two copies of the function, one with a pure delegate,  
> one without.
>
> On item 2, the reason I feel this way is in the case where foo wants to  
> pass the delegate to another pure function, it might optimize that call  
> differently if the delegate is known to be pure.  Or maybe we  
> don't/can't care...

That is a good point. However, pure delegates should (but might not
currently) be implicitly castable to impure. Hence, one version, taking
an impure delegate, should be enough.

Moreover, I believe a pure delegate could only ever be weakly-pure, hence
precluding the use of aggressive optimizations.

If my first assumption is correct, and the latter is not, the problem
should only occur if you have two versions of a function, one taking a
pure delegate, the other taking an impure one.


-- 
Simen