www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Precondition vs debug{}

reply Bill Baxter <dnewsgroup billbaxter.com> writes:
Is there any difference between these two methods of implementing a 
precondition?:

-----------------------
void foo(int x)
in {
    // do some checking
}
body
{
    ...
}
-----------------------

and this:

-----------------------
void foo(int x)
{
   debug {
      // do some checking
   }
   ...
}
-----------------------

And if "some checking" is just an assert() or two is there any 
difference between the 'in' precondition version and just plain

-----------------------
void foo(int x)
{
   assert(something, "something's not right");
   ...
}
-----------------------


Just curious.  Typing 'in' and 'body' just doesn't come naturally to me. 
  But I've seen plenty of D code with an in{}body{} pair where the in{} 
only contains one assert(), so I was wondering if there was some 
advantage to the extra verbiage that I was missing out on.

--bb
Oct 02 2007
next sibling parent reply Daniel Keep <daniel.keep.lists gmail.com> writes:
Bill Baxter wrote:
 Is there any difference between these two methods of implementing a
 precondition?:
 
 -----------------------
 void foo(int x)
 in {
    // do some checking
 }
 body
 {
    ...
 }
 -----------------------
 
 and this:
 
 -----------------------
 void foo(int x)
 {
   debug {
      // do some checking
   }
   ...
 }
 -----------------------

I think the primary difference is that debug sections are only compiled in if you throw the -debug switch, whereas contracts are *omitted* if you throw the -release switch.
 And if "some checking" is just an assert() or two is there any
 difference between the 'in' precondition version and just plain
 
 -----------------------
 void foo(int x)
 {
   assert(something, "something's not right");
   ...
 }
 -----------------------

AFAIK, there isn't. Well, unless your assert is "assert(false)" which never gets thrown out, unless it's in the 'in' contract and you throw -release.
 Just curious.  Typing 'in' and 'body' just doesn't come naturally to me.
  But I've seen plenty of D code with an in{}body{} pair where the in{}
 only contains one assert(), so I was wondering if there was some
 advantage to the extra verbiage that I was missing out on.
 
 --bb

Code documentation, perhaps? I like it because it provides a nice separation between contract assertions and the actual implementation. -- Daniel
Oct 02 2007
parent Bill Baxter <dnewsgroup billbaxter.com> writes:
Daniel Keep wrote:
 
 Bill Baxter wrote:
 Is there any difference between these two methods of implementing a
 precondition?:

 -----------------------
 void foo(int x)
 in {
    // do some checking
 }
 body
 {
    ...
 }
 -----------------------

 and this:

 -----------------------
 void foo(int x)
 {
   debug {
      // do some checking
   }
   ...
 }
 -----------------------

I think the primary difference is that debug sections are only compiled in if you throw the -debug switch, whereas contracts are *omitted* if you throw the -release switch.
 And if "some checking" is just an assert() or two is there any
 difference between the 'in' precondition version and just plain

 -----------------------
 void foo(int x)
 {
   assert(something, "something's not right");
   ...
 }
 -----------------------

AFAIK, there isn't. Well, unless your assert is "assert(false)" which never gets thrown out, unless it's in the 'in' contract and you throw -release.
 Just curious.  Typing 'in' and 'body' just doesn't come naturally to me.
  But I've seen plenty of D code with an in{}body{} pair where the in{}
 only contains one assert(), so I was wondering if there was some
 advantage to the extra verbiage that I was missing out on.

 --bb

Code documentation, perhaps? I like it because it provides a nice separation between contract assertions and the actual implementation. -- Daniel

Thanks. Your answers sum it up very nicely. --bb
Oct 03 2007
prev sibling parent Lutger <lutger.blijdestijn gmail.com> writes:
Two more differences I can think of:

Contracts are only left out when you compile without release, thus using 
'in-out-body' can be a way to compile in contracts without debug code. 
Not saying anything for or against this, but it's a possibility.

Contracts are also inherited although iirc this behavior isn't implemented.
Oct 03 2007