www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - object states

reply "Henning Pohl" <henning still-hidden.de> writes:
Imagine you want an image to keep the width of 512:

void func(Image img) {
     assert(img.width == 512);

     img.doSomething();
     assert(img.width == 512);

     while (img.somethingElse()) {
         assert(img.width == 512)

         someFunc(img);
         assert(img.width == 512);
     }
}

In theory, every call to a function can change the width of the 
image. What do you think about this: 
https://dl.dropbox.com/u/34762907/temp/prop1.html

I do know it can be implemented in D4 only.
Oct 07 2012
next sibling parent =?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:
On 10/07/2012 11:44 AM, Henning Pohl wrote:

 Imagine you want an image to keep the width of 512:

 void func(Image img) {
 assert(img.width == 512);

 img.doSomething();
 assert(img.width == 512);

 while (img.somethingElse()) {
 assert(img.width == 512)

 someFunc(img);
 assert(img.width == 512);
 }
 }

 In theory, every call to a function can change the width of the image.
 What do you think about this:
 https://dl.dropbox.com/u/34762907/temp/prop1.html

 I do know it can be implemented in D4 only.



Sounds good. You haven't mentioned the invariant keyword, so perhaps you 
are not aware of that feature?

   http://dlang.org/class.html#Invariant

   http://dlang.org/dbc.html

Although the docs seem to favor classes, invariant is available for 
structs as well.

Ali

-- 
D Programming Language Tutorial: http://ddili.org/ders/d.en/index.html
Oct 07 2012
prev sibling next sibling parent "Henning Pohl" <henning still-hidden.de> writes:
On Sunday, 7 October 2012 at 20:18:15 UTC, Ali Çehreli wrote:

 Sounds good.





 You haven't mentioned the invariant keyword, so perhaps you are 
 not aware of that feature?

   http://dlang.org/class.html#Invariant

   http://dlang.org/dbc.html

 Although the docs seem to favor classes, invariant is available 
 for structs as well.

 Ali



invariants? You cannot add/remove checks from invariants while 
using the object. That's what I made different. But there are 
still some limits given by the language. Look at point 7 for 
instance.

The problem about contract programming in general is you cannot 
use it in public library code. Distinction between logic and user 
input is a very important thing, we really need to improve this. 
You may have noticed that I did not make use of either assert or 
enforce. I didn't want to specify this.
Oct 07 2012
prev sibling next sibling parent "simendsjo" <simendsjo gmail.com> writes:
On Sunday, 7 October 2012 at 20:46:09 UTC, Henning Pohl wrote:

 On Sunday, 7 October 2012 at 20:18:15 UTC, Ali Çehreli wrote:

 Sounds good.





 You haven't mentioned the invariant keyword, so perhaps you 
 are not aware of that feature?

  http://dlang.org/class.html#Invariant

  http://dlang.org/dbc.html

 Although the docs seem to favor classes, invariant is 
 available for structs as well.

 Ali



 invariants? You cannot add/remove checks from invariants while 
 using the object. That's what I made different. But there are 
 still some limits given by the language. Look at point 7 for 
 instance.

 The problem about contract programming in general is you cannot 
 use it in public library code. Distinction between logic and 
 user input is a very important thing, we really need to improve 
 this. You may have noticed that I did not make use of either 
 assert or enforce. I didn't want to specify this.



You can create a wrapper struct that includes an invariant:

import std.stdio;

struct Image
{
     int width;

     void doSomething()
     {
     }

     void modifiesWidth()
     {
         --width;
     }
}

void func(Image img)
{
     struct ImgWrapper
     {
         Image* img;
         this(ref Image img)
         {
             this.img = &img;
         }

         invariant()
         {
             assert(img.width == 512);
         }

         void opDispatch(string s)()
         {
             mixin("img."~s~"();");
         }
     }

     auto wrapper = ImgWrapper(img);
     wrapper.doSomething();
     wrapper.modifiesWidth(); // assertion failure
}

void main()
{
     Image img = { 512 };
     func(img);
}
Oct 08 2012
prev sibling parent "Henning Pohl" <henning still-hidden.de> writes:
On Monday, 8 October 2012 at 08:53:39 UTC, simendsjo wrote:

 You can create a wrapper struct that includes an invariant:

 import std.stdio;

 struct Image
 {
     int width;

     void doSomething()
     {
     }

     void modifiesWidth()
     {
         --width;
     }
 }

 void func(Image img)
 {
     struct ImgWrapper
     {
         Image* img;
         this(ref Image img)
         {
             this.img = &img;
         }

         invariant()
         {
             assert(img.width == 512);
         }

         void opDispatch(string s)()
         {
             mixin("img."~s~"();");
         }
     }

     auto wrapper = ImgWrapper(img);
     wrapper.doSomething();
     wrapper.modifiesWidth(); // assertion failure
 }

 void main()
 {
     Image img = { 512 };
     func(img);
 }



There is a difference between invariants and what I call states. 
States clear things up when you actually need to do a runtime 
check and when not. Invariants are always checked, because you 
don't care about performance in debug mode. A Number<positive> is 
positive already and will stay positive while you can access it. 
De facto you cannot change a Number<positive> to a negative 
number.
Oct 08 2012