On Thursday, 29 June 2017 at 01:37:17 UTC, H. S. Teoh wrote:
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
https://github.com/dlang/dmd/pull/3799
