• Bill Baxter (36/36) Oct 02 2007 Is there any difference between these two methods of implementing a
• Daniel Keep (10/51) Oct 02 2007 I think the primary difference is that debug sections are only compiled
• Bill Baxter (3/61) Oct 03 2007 Thanks. Your answers sum it up very nicely.
• Lutger (5/5) Oct 03 2007 Two more differences I can think of:

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

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

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

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.