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

[H. S. Teoh via Digitalmars-d]

On Thu, Jun 29, 2017 at 01:22:31AM +0000, Mark via Digitalmars-d wrote:
[...]
> So basically, I'd like the ability to implement fairly simple
> contracts (with a similar level of sophistication to the above
> examples) that the compiler can check for me. I don't know, maybe this
> is easier to implement using UDAs...

One idea I have is that the compiler could recognize certain
straightforward contracts (like int < value) and use VRP (value range
propagation) to detect cases where it's clear that the contract would be
violated.

However, this can only be done in a very rudimentary fashion, because:

(1) DbC contracts pertain to *runtime* argument values, so while
checking for simple cases at compile-time is nice, it isn't really in
the charter of (D's implementation of) DbC.

(2) VRP in the compiler currently only works within a very limited
scope, IIRC within a single expression. So while it may detect the
`foo(bar())` case, it probably won't detect the `x=bar(); foo(x);` case.
Ostensibly the scope of VRP ought to be expanded, however:

(3) In the past Walter has shown some reluctance in adding features that
hurt compilation time; if a more sophisticated implementation of VRP is
required and it's deemed too expensive in terms of compilation time,
Walter may veto it.

(4) Arbitrarily complex boolean conditions are undecidable in general,
so unless you have a way to solve the halting problem, a general
solution is intractible.  Of course, the kind of conditions you find in
contracts generally ought to be nowhere near the halting problem in
complexity, but it's not clear how far one can go without running the
risk of (3).  My guess is that something based on VRP is the most likely
to materialize in the foreseeable future.


T

-- 
First Rule of History: History doesn't repeat itself -- historians merely repeat each other.