DIP 1009--Improve Contract Usability--Preliminary Review Round 1

[jmh530 via Digitalmars-d]

On Thursday, 22 June 2017 at 12:21:29 UTC, MysticZach wrote:
>
> I understand. Thus, a better DIP would suggest reimplementing 
> D's DbC system altogether. Because as it is, they are little 
> more than syntax dressing, which happens to be less convenient 
> that just writing out the asserts in the first place. They're 
> more like syntax _vinegar_ than sugar. Which explains why 
> hardly anyone uses them. Why write this:
>
> int fun(int a)
> in { assert (a); }
> do {
>     return a;
> }
>
> ...when you could just do this:
>
> int fun(int a) {
>    assert(a);
>    return a;
> }
>

My recollection is that the most significant reason to use 
contracts in D is because of contract inheritance. There's a lot 
of focus in this discussion on normal functions, when I would say 
that contracts really aren't even needed.

So a more useful situation to consider then is:

class Foo
{
     int fun(int a)
     in {
         assert(a > 0 && a < 10);
     }
     body {
         return a;
     }
}

class Bar : Foo
{
     int fun(int a)
     in {assert(a > 0);}
     body {
         return a;
     }
}

I would say keep the current behavior for backwards compatibility 
(maybe with the body/do change), but also allow the following 
code:

class Foo
{
     int fun(int a)
     {
         in {
             assert(a > 0 && a < 10);
         }
         return a;
     }
}

class Bar : Foo
{
     int fun(int a)
     {
         in {assert(a > 0);}
         return a;
     }
}

where the compiler would effectively re-write this into the code 
above. You wouldn't need to make a change to interfaces since 
they don't have bodies anyway.