In some D programs I'm using this coding pattern:
struct Foo {
// Instance fields here.
@disable this();
this(in string[] data) pure @safe
in {
// Many pre-conditions here.
} out(result) {
// Some post-conditions here.
} body {
// ...
}
Nullable!(string[][]) doIt() pure {
//...
}
// Various other methods here...
}
void main() {
// Created at compile-time.
enum something = "........".Foo;
// Something much larger is done at run-time.
immutable const result = something.doIt;
}
The structure is created at compile-time using data known at
compile-time (here a string). This struct has a constructor that
runs at compile-time that has many pre-conditions that avoid
wrong input data at compile-time.
The largest part of the computation is done at run-time calling
one or more struct methods.
And the @disable this() assures that a struct is correctly
initialized by the constructor.
This pattern has significant advantages regarding code
reliability.
You can see an example of this pattern that I've used here:
http://rosettacode.org/wiki/Solve_a_Hopido_puzzle#D
Bye,
bearophile
