On 3/13/2014 3:21 PM, Timon Gehr wrote:
On 03/13/2014 02:32 PM, Steven Schveighoffer wrote:
The one I would really like to see is logical OR. There is no easy way
around this, one must come up with convoluted mechanisms that are much
harder to design, write, and understand than just version(x || y)
version(A) version=AorB;
version(B) version=AorB;
version(AorB){ }
If you're writing things like that, it's still missing the point. The point is
not to find workarounds, but to rethink just what feature is being version'd on.
For example, suppose it's wrapping a call to SomeWackyFunction:
version (Linux)
SomeWackyFunction();
else version (OSX)
SomeWackyFunction();
else
... workaround ...
Execrable answer:
version (Linux) version=LinuxOrOSX;
version (OSX) version=LinuxOrOSX;
...
version (LinuxOrOSX)
SomeWackyFunction();
else
... workaround ...
This is execrable because LinuxOrOSX:
1. has no particular relationship to SomeWackyFunction()
2. makes for confusion if LinuxOrOSX is used also to version in other things
3. makes for what do I do if I add in FreeBSD? Rename to LinuxOrOSXOrFreeBSD ?
yeech
Better answer:
version (Linux) version=hasSomeWackyFunction;
version (OSX) version=hasSomeWackyFunction;
...
version (hasSomeWackyFunction)
SomeWackyFunction();
else
... workaround ...
At least this is maintainable, though it's clumsy if that code sequence appears
more than once or, worse, must be replicated in multiple modules.
Even better:
--------
import wackyfunctionality;
...
WackyFunction();
--------
module wackyfunctionality;
void WackyFunction() {
version (Linux)
SomeWackyFunction();
else version (OSX)
SomeWackyFunction();
else
... workaround ...
}
--------
Simple, maintainable, easy on the eye.
