Am 19.11.2016 um 22:16 schrieb Dicebot:
DIP 1003 is merged to the queue and open for public informal feedback.

Initial merged document:

If you want the change to be approved and have ideas how to improve it
to better match on and existing
published reviews - please submit new PR with editorial and ping
original author.

I'd really like to see option 3, combined with option 1. The verbosity of the current syntax, as well as the sub-optimal contract semantics for classes*, make me personally almost always resort to normal assertions in the function body instead of using contracts.

That "body" is not available as an identifier is also quite annoying for certain applications. This is the case for a bunch of other keywords, too, but "body" as a keyword just has extremely little value, so it does stick out.

Really nice would be if "in" and "out" would then also take a general statement instead of just a block statement, so that a syntax like this would become possible for simple contracts:

    void foo(int a, int b)
      in assert(0 <= a && a < b);
      out(ret) assert(ret < b);
      return b - 1 - a;

The current equivalent just looks crowded and becomes hard to read, or wastes lots of vertical space if braces are put on their own line:

    void foo(int a, int b)
      in { assert(0 <= a && a < b); }
      out(ret) { assert(ret < b); }
    body {
      return b - 1 - a;

For this whole proposal to work out, though, I think the old syntax will have to stay supported without deprecations, because the amount of breakage (the deprecation path won't change that) will otherwise probably be huge. Making "body" optional + contextual seems to be the way to go.

Since "body" is only used in a tiny and specific grammatical niche of the language, I also think that Walter's generic arguments form the linked thread don't really apply here, similar to "scope(...)" or "extern(...)".

* Example:

    interface Foo {
      void foo(int x) in { assert(x < 10); };

    class Bar : Foo {
      // no contract enforced, because an omitted contract always
      // counts as a passing contract - need in { assert(false); } here
      override void foo(int x) { ... }

Reply via email to