Design by Contract - out old struct member value

[Brother Bill]

On Wednesday, 6 August 2025 at 16:19:17 UTC, Nick Treleaven wrote:
> On Wednesday, 6 August 2025 at 15:43:01 UTC, Brother Bill wrote:
>> How is this done in D?
>
> I thought the following would work, but the compiler doesn't 
> like `this.count` as a default argument:
>
> ```d
> struct Counter {
>    int count;
>
>    void incrementBy(int increment, int preCount = this.count)
>    in {
>       assert(increment >= 0, "increment must be zero or 
> greater");
>    }
>    out {
>        assert(count == preCount + increment);
>    }
>    do {
>       this.count += increment;
>    }
> }
> ```
>
> And I exp
ect you'd like to avoid adding a function parameter
> anyway.


This hack gets the job done, at the cost of an extra struct 
member and an assignment.
If this code is conditionally compiled, then the extra struct 
member and the extra setting of oldCount can be removed from 
release (production) version.

The additional code is manually entered for now as a "proof of 
concept".

```
import std.stdio;

void main() {
	Counter counter = { count: 42 };
	writeln("counter(42): ", counter.count);
	
	counter.incrementBy(100);
	writeln("after incrementBy(100): ", counter.count);
}

struct Counter {
	int count;
	private int oldCount;

	void incrementBy(int increment)
	in {
		assert (increment >= 0, "increment must be non-negative");
	}
	out {
		assert(count == oldCount + increment, "count = old count + 
increment");
	}
	do {
		// Capture oldCount
		oldCount = count;

		// body
		count += increment;
	}

}
```

Can we do better than this?

IMHO, DbC (Design by Contract) is one of the great features in D 
"borrowed" from Eiffel.
It would be even better with old(count) or old count, where old 
would be a "keyword" specially treated in the postcondition "out" 
block only.  It would capture the count member implicitly at the 
start of the do block.
```
	out {
		assert(count == old count + increment, "count = old count + 
increment");
	}
```