[proposal] version statements with multiple arguments.
Looking at std.io (hopefully the right version maybe?) I see this:
version(OSX)
{ do something; }
version(Windows)
{ do the same thing as above; }
version(FreeBSD)
{ ditto; }
version(Linux)
{ finally do something different; }
and:
version(Windows) version(DigitalMars)
{ something; }
I was rather surprised that this wasn't accepted:
//Error: found '||' when expecting ')'
version(OSX || Windows || FreeBSD)
{ do something; }
version(Linux)
{ do something different; }
The last one could be intuitively described as:
version(Windows && DigitalMars)
{ blah; }
So I guess in the end I am proposing a change.
A change that I cannot see breaking backwards compatibility while also
shortening code duplication.
It also seems much more 'intuitive' to me.
version(Windows) version(DigitalMars) {}
made me think twice to make sure I knew what it was doing.
What do you guys think? If this was implemented, how could it break
backwards compatibility?
Is something like this worth a change?
Are there any drawbacks to this idea?
--
Shut up, Opera.
Re: [proposal] version statements with multiple arguments.
On Tuesday, 23 October 2012 at 03:22:08 UTC, 1100110 wrote:
So I guess in the end I am proposing a change.
A change that I cannot see breaking backwards compatibility
while also shortening code duplication.
It also seems much more 'intuitive' to me.
version(Windows) version(DigitalMars) {}
made me think twice to make sure I knew what it was doing.
What do you guys think? If this was implemented, how could it
break backwards compatibility?
Is something like this worth a change?
Are there any drawbacks to this idea?
This "issue" comes once in a while. The suggested solution:
version(OSX)
version = Somethingable
version(Windows)
version = Somethingable
version(FreeBSD)
version = Somethingable
version(Somethingable)
dosomething();
version(Linux)
otherthing;
Not necessarily more concise but it can add description to what
the actual version being created.
Re: [proposal] version statements with multiple arguments.
Indeed, having version logic has been requested many times before.
For example:
http://www.digitalmars.com/d/archives/digitalmars/D/learn/Can_I_do_an_or_in_a_version_block_33426.html
http://www.digitalmars.com/d/archives/digitalmars/D/11946.html
quote from those:
"Walter would reject it. He has stated clearly in the past that
he intended version to be simple and minimal, and that adding
anything onto it will only result in abuses."
I tend to think that not having version logic (&&,||,!) results
in greater abuse, ie people WILL come up with their own
incompatible, verbose solutions (string mixins and whatnot) to
achieve the same results;
Another point is that we are sometimes too lazy to write
statements as follows:
version (linux){ version = linuxOrBSD;}
version (BSD){ version = linuxOrBSD;}
version(linuxOrBSD){do_something;}
(that's ugly but it's the official recommended way; much more
verbose than:
version(linux || BSD){do_something;}
)
and instead we lazily duplicate code, because "do_something" is
small enough:
version (linux){ do_something;}
version (BSD){ do_something;}
Later on we (or the maintainer) update the first "do_something"
and forget to update the second. Bug follows.
Seriously who hasn't encountered that?
Might as well provide a clean standard solution so everybody uses
it. It should be easy to implement and wont' break any code.
Re: [proposal] version statements with multiple arguments.
On Mon, 22 Oct 2012 22:31:43 -0500, Jesse Phillips
wrote:
On Tuesday, 23 October 2012 at 03:22:08 UTC, 1100110 wrote:
So I guess in the end I am proposing a change.
A change that I cannot see breaking backwards compatibility while also
shortening code duplication.
It also seems much more 'intuitive' to me.
version(Windows) version(DigitalMars) {}
made me think twice to make sure I knew what it was doing.
What do you guys think? If this was implemented, how could it break
backwards compatibility?
Is something like this worth a change?
Are there any drawbacks to this idea?
This "issue" comes once in a while. The suggested solution:
[snip]
Not necessarily more concise but it can add description to what the
actual version being created.
That is true, and I do recall that version = something; now that I think
about it.
It just seems to me that version statements are essentially booleans, and
could be easily rewritten as:
static if(true || false || false) { } by the compiler, similar to how (I
*think*) certain binary operators are rewritten.
(I'm just going by what I hear, I'm not really a compiler kinda guy...)
It would make sense to me to be able to use boolean operators on what is
essentially
a true/false statement.
I'd be willing to see if I can hack together support for it, as a proof of
concept,
but I wanted to see if it would be blatantly shot down first.
So... What I'd really like to know is: Would *you* welcome such a change?
--
Using Opera's revolutionary email client: http://www.opera.com/mail/
Re: [proposal] version statements with multiple arguments.
On Tuesday, 23 October 2012 at 04:32:02 UTC, 1100110 wrote:
On Mon, 22 Oct 2012 22:31:43 -0500, Jesse Phillips
wrote:
That is true, and I do recall that version = something; now
that I think about it.
It just seems to me that version statements are essentially
booleans, and could be easily rewritten as:
static if(true || false || false) { } by the compiler, similar
to how (I *think*) certain binary operators are rewritten.
(I'm just going by what I hear, I'm not really a compiler kinda
guy...)
It would make sense to me to be able to use boolean operators
on what is essentially
a true/false statement.
I'd be willing to see if I can hack together support for it, as
a proof of concept,
but I wanted to see if it would be blatantly shot down first.
So... What I'd really like to know is: Would *you* welcome such
a change?
This proposal has made a quarterly appearance since the earliest
days of D1... and heavens yes, would I welcome it. While the
standard (version = Somethingable) approach is actually fine in
many cases (self documenting, puts all the logic in one place,
etc etc) it is also quite overkill in many cases (the logic
matters exactly once, the logic branches differently in different
places, etc etc). It's the same as every toolbox having
different types of screwdrivers. Yes they do the same thing, but
in different circumstances one will be clearly preferable over
another.
-- Chris Nicholson-Sauls
Re: [proposal] version statements with multiple arguments.
On 10/22/2012 8:17 PM, 1100110 wrote:
> The last one could be intuitively described as:
> version(Windows && DigitalMars)
> { blah; }
It was a very deliberate design choice to not allow !, || or && in version
statements. Such tend to devolve over time into unmaintainable chaos.
Re: [proposal] version statements with multiple arguments.
On 10/22/2012 9:26 PM, timotheecour wrote:
> Another point is that we are sometimes too lazy to write statements as
follows:
> version (linux){ version = linuxOrBSD;}
> version (BSD){ version = linuxOrBSD;}
> version(linuxOrBSD){do_something;}
> (that's ugly but it's the official recommended way; much more verbose than:
> version(linux || BSD){do_something;}
> )
1. Verbosity is not the enemy. Clarity is the goal.
2. The example would be better as:
version (linux){ version = Something;}
version (BSD){ version = Something;}
version(Something){do_Something;}
where Something is the name of the feature being enabled. With careful selection
of Something, the code can be quite readable.
Re: [proposal] version statements with multiple arguments.
On 23/10/12 05:17, 1100110 wrote:
Looking at std.io (hopefully the right version maybe?) I see this:
version(OSX)
{ do something; }
version(Windows)
{ do the same thing as above; }
version(FreeBSD)
{ ditto; }
version(Linux)
{finally do something different; }
and:
version(Windows) version(DigitalMars)
{ something; }
I was rather surprised that this wasn't accepted:
//Error: found '||' when expecting ')'
version(OSX || Windows || FreeBSD)
{ do something; }
version(Linux)
{ do something different; }
The last one could be intuitively described as:
version(Windows && DigitalMars)
{ blah; }
That allows you to create the same bird's nest that you can get with
#ifdef in C.
See bug 7417 for a different solution that fixes other problems as well.
Just make version declarations behave like bool variable declarations:
version useTheOrdinaryWay = OSX || Windows || FreeBSD;
version dmdWindows = Windows && DigitalMars;
version (dmdWindows) { blah; }
Re: [proposal] version statements with multiple arguments.
On 24/10/2012 10:40, Don Clugston wrote:
On 23/10/12 05:17, 1100110 wrote:
Looking at std.io (hopefully the right version maybe?) I see this:
version(OSX)
{ do something; }
version(Windows)
{ do the same thing as above; }
version(FreeBSD)
{ ditto; }
version(Linux)
{finally do something different; }
and:
version(Windows) version(DigitalMars)
{ something; }
I was rather surprised that this wasn't accepted:
//Error: found '||' when expecting ')'
version(OSX || Windows || FreeBSD)
{ do something; }
version(Linux)
{ do something different; }
The last one could be intuitively described as:
version(Windows && DigitalMars)
{ blah; }
That allows you to create the same bird's nest that you can get with
#ifdef in C.
See bug 7417 for a different solution that fixes other problems as well.
Just make version declarations behave like bool variable declarations:
version useTheOrdinaryWay = OSX || Windows || FreeBSD;
version dmdWindows = Windows && DigitalMars;
version (dmdWindows) { blah; }
Vote up!
http://d.puremagic.com/issues/show_bug.cgi?id=7417
