www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.announce - DMD 0.149 release

reply "Walter Bright" <newshound digitalmars.com> writes:
Changed on_scope keywords per the general consensus of the n.g.

The implicit function template instantiation is a bit limited at the moment, 
deduction won't work for types derived from templates, and the mechanism to 
pick the most specialized template doesn't work.

http://www.digitalmars.com/d/changelog.html
Mar 07 2006
next sibling parent reply Georg Wrede <georg.wrede nospam.org> writes:
Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.
 
 The implicit function template instantiation is a bit limited at the
 moment, deduction won't work for types derived from templates, and
 the mechanism to pick the most specialized template doesn't work.

Aahh, being modest.....
 http://www.digitalmars.com/d/changelog.html

I'd sure hate to be married with you!!!! :-) Just impressive! --- BTW, what does "Implicit casts of non-bool to bool disallowed" mean?
Mar 07 2006
parent reply "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"Georg Wrede" <georg.wrede nospam.org> wrote in message 
news:440E1336.3050608 nospam.org...
 BTW, what does "Implicit casts of non-bool to bool disallowed" mean?

It means you can no longer write bool x = 5;
Mar 07 2006
parent reply Georg Wrede <georg.wrede nospam.org> writes:
Jarrett Billingsley wrote:
 "Georg Wrede" <georg.wrede nospam.org> wrote in message 
 news:440E1336.3050608 nospam.org...
 
BTW, what does "Implicit casts of non-bool to bool disallowed" mean?

It means you can no longer write bool x = 5;

Shhhhhttt! Good-bye C/C++ folks! It's not like anybody would want to write exactly bool x = 5; but more like bool x = strcmp("foo", "bar"); if (!x) { /* do stuff */ } // match else { /* call the cops! */ } // no match which, incidentally, is one of the more profound proposititions in any C-derived language. The Old School Boolean C Logic was a perfectly functioning Concept. This fact _alone_ was the reason "Bool" took so long to be "formally" introduced into either C or C++. No regular programmer ever needed Prude Bool, only the Superior Theoreticians Thought it Wise to force this upon the language. It was profoundly useful as-is, and didn't need any pimping. A language that purports to be "to-the-metal" just has to take into consideration the fundamentals of [digital] life. And processor physics. (Wanna abstract away that? Then go to Java or whatever.) The other night [in the D newsgroup, when it was getting hilarious] it dawned to me, that quite [too] many of the vocatious NG-members never had read their Boolean IT Fundamentals. Good Grief: "there's just too many instances in history where the illiterati have dictated the outcome of otherwise intellectual confrontations". Damn!! The ramifications of this (minor looking) modification are grave, I'm afraid. Now what happens to if (stcmp("foo", "bar")) {} ???
Mar 07 2006
next sibling parent reply "Chris Miller" <chris dprogramming.com> writes:
On Tue, 07 Mar 2006 19:47:38 -0500, Georg Wrede <georg.wrede nospam.org>  
wrote:

 but more like

      bool x = strcmp("foo", "bar");
      if (!x) { /* do stuff */ }        // match
      else { /* call the cops! */ }     // no match

You shouldn't even be doing that! You're inverting the meaning of true and false. Use int.
 Now what happens to

      if (stcmp("foo", "bar")) {}

If this wasn't allowed I'd be furious.
Mar 07 2006
parent reply Georg Wrede <georg.wrede nospam.org> writes:
Chris Miller wrote:
 On Tue, 07 Mar 2006 19:47:38 -0500, Georg Wrede 
 <georg.wrede nospam.org>  wrote:
 
 but more like

      bool x = strcmp("foo", "bar");
      if (!x) { /* do stuff */ }        // match
      else { /* call the cops! */ }     // no match

You shouldn't even be doing that! You're inverting the meaning of true and false. Use int.

Yeah, I know. (In hindsight, in this NG, maybe I should have tried to find a C function that returns 0 on failure. :-) ) Then again it's supposed to be easy to use C from D, and there are a lot of functions that return int values such that zero signifies true and anything else signifies false, and, one is also supposed to be able to use the particular [nonzero] return value for other purposes. (Call this old school efficiency or whatever, but as long as we are supposed to use C libraries, that's what we'll have to live with.)
 Now what happens to

      if (stcmp("foo", "bar")) {}

If this wasn't allowed I'd be furious.

I bet you wouldn't be alone! In the first example, the reason for using bool was to be explicit about *not* intending to use the value for other than true/false, otherwise of course an int would be used instead. Admittedly, bool x = strcmp("foo", "bar"); is bad code. Inverted meaning of x, and also a nonobvious name for a boolean variable. Better would be bool areDifferent = strcmp("foo", "bar"); (which unfortunately doesn't compile on 0.149), or better bool stringsMatch = ! strcmp("foo", "bar"); but this would have diverted the point of the example, since the "!" makes the code compilable! For C functions that return int to signify truth value, one now (as of 0.149) has to do a cast. That becomes cumbersome if one has to do a lot of C library usage. It also makes the code less readable. Seems there are two options bool a,b,c,d; a = cast(bool) strcmp("foo", "bar"); b = cast(bool) strcmp("foo", "baf"); c = cast(bool) strcmp("foo", "bag"); d = cast(bool) strcmp("foo", "bad"); or the newly found "cast to bool operator", brought up by BCS (in D.announce 3032) a = !! strcmp("foo", "bar"); b = !! strcmp("foo", "baf"); c = !! strcmp("foo", "bag"); d = !! strcmp("foo", "bad"); This is certainly less typing, and it shrouds less the original code. If it weren't for this discovery, I'd have a *hard time* living with this last change in D. So the "!!" might become a much used idiom in D now. I wonder what the reaction from the C++ crowd will be. --- (Aside:) In real code of course, one should never invert booleans, and one should always use variable names with semantic content for the reader. Thus, one probably would write something like bool match; match = ! strcmp("foo", "bar"); if (match) { /* do stuff */ } else { /* call the cops! */ }
Mar 08 2006
next sibling parent Oskar Linde <oskar.lindeREM OVEgmail.com> writes:
Georg Wrede skrev:
 or the newly found "cast to bool operator", brought up by BCS (in 
 D.announce 3032)
 
     a = !! strcmp("foo", "bar");
     b = !! strcmp("foo", "baf");
     c = !! strcmp("foo", "bag");
     d = !! strcmp("foo", "bad");
 
 This is certainly less typing, and it shrouds less the original code. If 
 it weren't for this discovery, I'd have a *hard time* living with this 
 last change in D.
 
 So the "!!" might become a much used idiom in D now. I wonder what the 
 reaction from the C++ crowd will be.

I've used !! to clamp a value to {0,1} in C since ages. One advantage of having to use !! is that the performance penalty of converting to bool is no longer hidden. (This may not be so bad on x86 (or, setne), but may on other architectures involve branching). /Oskar
Mar 08 2006
prev sibling parent "Derek Parnell" <derek psych.ward> writes:
On Wed, 08 Mar 2006 21:49:22 +1100, Georg Wrede <georg.wrede nospam.org>  
wrote:

 For C functions that return int to signify truth value, one now (as of  
 0.149) has to do a cast. That becomes cumbersome if one has to do a lot  
 of C library usage. It also makes the code less readable.

I'd like to bring up two points about this. Firstly, the strcmp() function is not really the one you need to have as an example of C-programs-that-return-an-int-as-a-boolean. This function is actually designed to return one of *three* values - not a boolean. It returns zero if the two strings are equal, an integer less than zero if the first string is less than the second, and an integer greater than zero if the first string is greater than the second. So the proper way to use this return value is to compare it to zero. if (strcmp("foo", datafld ) == 0) // equal strings if (strcmp("foo", datafld ) < 0) // "foo" is less than datafld if (strcmp("foo", datafld ) > 0) // "foo" is greater than datafld if (strcmp("foo", datafld ) != 0) // "foo" is different to datafld etc ... Using the result as if it is a boolean is a mistake. The second point is that C is not D. When interfacing with any foreign data source, one must expect to do data conversions when the two systems implement similar paradigms differently. Thus if one is interfacing to a C function and that C function returns a boolean that is implemented as an int, the D program ought to convert the C data into the equivalent D data form. This is a good programming practice. By the way, if strcmp() was even converted to a pure D function, it still wouldn't return a bool.
 Seems there are two options

      bool a,b,c,d;

      a = cast(bool) strcmp("foo", "bar");
      b = cast(bool) strcmp("foo", "baf");
      c = cast(bool) strcmp("foo", "bag");
      d = cast(bool) strcmp("foo", "bad");

 or the newly found "cast to bool operator", brought up by BCS (in  
 D.announce 3032)

      a = !! strcmp("foo", "bar");
      b = !! strcmp("foo", "baf");
      c = !! strcmp("foo", "bag");
      d = !! strcmp("foo", "bad");

 This is certainly less typing, and it shrouds less the original code. If  
 it weren't for this discovery, I'd have a *hard time* living with this  
 last change in D.

But it is wrong to treat strcmp this way, but I understand that this is not your point really. Clarity in code is to write in such a way as to make your intentions obvious to other readers of your code.
 So the "!!" might become a much used idiom in D now.

I don't think so...it is too obtuse and not very clear.
 ---

 (Aside:) In real code of course, one should never invert booleans, and  
 one should always use variable names with semantic content for the  
 reader. Thus, one probably would write something like


      bool match;

      match = ! strcmp("foo", "bar");

      if (match)
      {
          /* do stuff */
      }
      else
      {
          /* call the cops! */
      }

Actually, it probably should be more like ... match = (strcmp("foo", "bar") == 0); -- Derek Parnell Melbourne, Australia
Mar 08 2006
prev sibling next sibling parent reply Kyle Furlong <kylefurlong gmail.com> writes:
Georg Wrede wrote:
 Jarrett Billingsley wrote:
 "Georg Wrede" <georg.wrede nospam.org> wrote in message 
 news:440E1336.3050608 nospam.org...

 BTW, what does "Implicit casts of non-bool to bool disallowed" mean?

It means you can no longer write bool x = 5;

Shhhhhttt! Good-bye C/C++ folks! It's not like anybody would want to write exactly bool x = 5; but more like bool x = strcmp("foo", "bar"); if (!x) { /* do stuff */ } // match else { /* call the cops! */ } // no match which, incidentally, is one of the more profound proposititions in any C-derived language. The Old School Boolean C Logic was a perfectly functioning Concept. This fact _alone_ was the reason "Bool" took so long to be "formally" introduced into either C or C++. No regular programmer ever needed Prude Bool, only the Superior Theoreticians Thought it Wise to force this upon the language. It was profoundly useful as-is, and didn't need any pimping. A language that purports to be "to-the-metal" just has to take into consideration the fundamentals of [digital] life. And processor physics. (Wanna abstract away that? Then go to Java or whatever.) The other night [in the D newsgroup, when it was getting hilarious] it dawned to me, that quite [too] many of the vocatious NG-members never had read their Boolean IT Fundamentals. Good Grief: "there's just too many instances in history where the illiterati have dictated the outcome of otherwise intellectual confrontations". Damn!! The ramifications of this (minor looking) modification are grave, I'm afraid. Now what happens to if (stcmp("foo", "bar")) {} ???

I suggest you read this : http://www.digitalmars.com/d/type.html before you make an ass of yourself. Oops, too late.
Mar 07 2006
parent Georg Wrede <georg.wrede nospam.org> writes:
Kyle Furlong wrote:
 Georg Wrede wrote:
 
 I suggest you read this : http://www.digitalmars.com/d/type.html before 
 you make an ass of yourself. Oops, too late.

Gee, you really must love me! Ok, I'll check that out.
Mar 07 2006
prev sibling next sibling parent Hasan Aljudy <hasan.aljudy gmail.com> writes:
Ever heard that D supprts == on strings? =P

if( "foo" == "bar" )
{
	//code that never executes
}



Georg Wrede wrote:
 Jarrett Billingsley wrote:
 
 "Georg Wrede" <georg.wrede nospam.org> wrote in message 
 news:440E1336.3050608 nospam.org...

 BTW, what does "Implicit casts of non-bool to bool disallowed" mean?

It means you can no longer write bool x = 5;

Shhhhhttt! Good-bye C/C++ folks! It's not like anybody would want to write exactly bool x = 5; but more like bool x = strcmp("foo", "bar"); if (!x) { /* do stuff */ } // match else { /* call the cops! */ } // no match which, incidentally, is one of the more profound proposititions in any C-derived language. The Old School Boolean C Logic was a perfectly functioning Concept. This fact _alone_ was the reason "Bool" took so long to be "formally" introduced into either C or C++. No regular programmer ever needed Prude Bool, only the Superior Theoreticians Thought it Wise to force this upon the language. It was profoundly useful as-is, and didn't need any pimping. A language that purports to be "to-the-metal" just has to take into consideration the fundamentals of [digital] life. And processor physics. (Wanna abstract away that? Then go to Java or whatever.) The other night [in the D newsgroup, when it was getting hilarious] it dawned to me, that quite [too] many of the vocatious NG-members never had read their Boolean IT Fundamentals. Good Grief: "there's just too many instances in history where the illiterati have dictated the outcome of otherwise intellectual confrontations". Damn!! The ramifications of this (minor looking) modification are grave, I'm afraid. Now what happens to if (stcmp("foo", "bar")) {} ???

Mar 07 2006
prev sibling next sibling parent Derek Parnell <derek psych.ward> writes:
On Wed, 08 Mar 2006 02:47:38 +0200, Georg Wrede wrote:

 Jarrett Billingsley wrote:
 "Georg Wrede" <georg.wrede nospam.org> wrote in message 
 news:440E1336.3050608 nospam.org...
 
BTW, what does "Implicit casts of non-bool to bool disallowed" mean?

It means you can no longer write bool x = 5;

Shhhhhttt! Good-bye C/C++ folks! It's not like anybody would want to write exactly bool x = 5; but more like bool x = strcmp("foo", "bar"); if (!x) { /* do stuff */ } // match else { /* call the cops! */ } // no match

Why would anyone in their right mind code something as stupid as that? This just misleads people who have to read your code. Instead do either ... bool x = cast(bool)strcmp("foo", "bar"); or int x = strcmp("foo", "bar"); or auto x = strcmp("foo", "bar"); In other words, code what you mean and mean what you code.
 which, incidentally, is one of the more profound proposititions in any 
 C-derived language.

Profoundly dumb. <g>
 The Old School Boolean C Logic was a perfectly functioning Concept. This 
 fact _alone_ was the reason "Bool" took so long to be "formally" 
 introduced into either C or C++. No regular programmer ever needed Prude 
 Bool, only the Superior Theoreticians Thought it Wise to force this upon 
 the language. It was profoundly useful as-is, and didn't need any 
 pimping. 

Are you deliberately trolling? I am a "regular programmer" and a correctly implemented boolean type is exactly what I need. What on Earth is "profoundly useful" about assigning a number to a boolean variable? It is far better (read: cost efficient at compile time, run time, and maintenance time) to code your intentions rather than taking advantage of a language's quirky 'features'. Such behaviour is only (IMNSHO) acceptable in absolutely runtime performance critical fragments, and then only if heavily and accurately documented.
 A language that purports to be "to-the-metal" just has to take 
 into consideration the fundamentals of [digital] life. And processor 
 physics. (Wanna abstract away that? Then go to Java or whatever.)

You seem to be confusing implementation with syntax/semantics. The compiler can do the semantic analysis correctly and then implement the code in the most efficient manner for the target platform. These are independent of each other.
 The other night [in the D newsgroup, when it was getting hilarious] it 
 dawned to me, that quite [too] many of the vocatious NG-members never 
 had read their Boolean IT Fundamentals.

And yet, you don't seem to "get it" either.
 Good Grief: "there's just too many instances in history where the 
 illiterati have dictated the outcome of otherwise intellectual 
 confrontations". Damn!!
 
 The ramifications of this (minor looking) modification are grave, I'm 
 afraid.
 
 Now what happens to
 
      if (stcmp("foo", "bar")) {}
 
 ???

This really shows that you are reading too much into the issue and not reading the specs themselves. In fact, a 2-minute test would answer this question for you anyway! import std.stdio; int Foo(int x) { return x; } void main() { bool x = cast(bool)Foo(0); if (!x) { writefln(" do stuff "); } else { writefln("call the cops!"); } if(Foo(2)) writefln("Foo(2)"); if(Foo(0)) writefln("Foo(0)"); } -- Derek (skype: derek.j.parnell) Melbourne, Australia "Down with mediocracy!" 8/03/2006 12:14:18 PM
Mar 07 2006
prev sibling next sibling parent reply "Ameer Armaly" <ameer_armaly hotmail.com> writes:
"Georg Wrede" <georg.wrede nospam.org> wrote in message 
news:440E29AA.1090408 nospam.org...
 Jarrett Billingsley wrote:
 "Georg Wrede" <georg.wrede nospam.org> wrote in message 
 news:440E1336.3050608 nospam.org...

BTW, what does "Implicit casts of non-bool to bool disallowed" mean?

It means you can no longer write bool x = 5;

Shhhhhttt! Good-bye C/C++ folks! It's not like anybody would want to write exactly bool x = 5; but more like bool x = strcmp("foo", "bar"); if (!x) { /* do stuff */ } // match else { /* call the cops! */ } // no match which, incidentally, is one of the more profound proposititions in any C-derived language. The Old School Boolean C Logic was a perfectly functioning Concept. This fact _alone_ was the reason "Bool" took so long to be "formally" introduced into either C or C++. No regular programmer ever needed Prude Bool, only the Superior Theoreticians Thought it Wise to force this upon the language. It was profoundly useful as-is, and didn't need any pimping. A language that purports to be "to-the-metal" just has to take into consideration the fundamentals of [digital] life. And processor physics. (Wanna abstract away that? Then go to Java or whatever.) The other night [in the D newsgroup, when it was getting hilarious] it dawned to me, that quite [too] many of the vocatious NG-members never had read their Boolean IT Fundamentals. Good Grief: "there's just too many instances in history where the illiterati have dictated the outcome of otherwise intellectual confrontations". Damn!! The ramifications of this (minor looking) modification are grave, I'm afraid. Now what happens to if (stcmp("foo", "bar")) {} ???

cast an int to a bool; it allows the above stated functionality, but doesn't really present any harms that I can see.
Mar 07 2006
parent Derek Parnell <derek psych.ward> writes:
On Tue, 7 Mar 2006 21:02:11 -0500, Ameer Armaly wrote:

 Now what happens to

     if (stcmp("foo", "bar")) {}

 ???

cast an int to a bool; it allows the above stated functionality, but doesn't really present any harms that I can see.

You *can* cast an integer to a bool, but it must be explicit and no implicit. bool x = cast(bool)42; // okay bool x = 42; // not okay -- Derek (skype: derek.j.parnell) Melbourne, Australia "Down with mediocracy!" 8/03/2006 1:11:07 PM
Mar 07 2006
prev sibling next sibling parent reply BCS <BCS_member pathlink.com> writes:
 It's not like anybody would want to write exactly
 
     bool x = 5;
 
 but more like
 
     bool x = strcmp("foo", "bar");
     if (!x) { /* do stuff */ }        // match
     else { /* call the cops! */ }     // no match
 

"!!" ends up as a cast to bool try: import std.stdio; int main() { int i = 1; int j = 2; int k = 0; if(!!i)writef("i\n");else writef("!i\n"); if(!!j)writef("j\n");else writef("!j\n"); if(!!k)writef("k\n");else writef("!k\n"); return 0; }
Mar 07 2006
parent reply Derek Parnell <derek psych.ward> writes:
On Tue, 07 Mar 2006 18:12:41 -0800, BCS wrote:

 It's not like anybody would want to write exactly
 
     bool x = 5;
 
 but more like
 
     bool x = strcmp("foo", "bar");
     if (!x) { /* do stuff */ }        // match
     else { /* call the cops! */ }     // no match
 

"!!" ends up as a cast to bool try: import std.stdio; int main() { int i = 1; int j = 2; int k = 0; if(!!i)writef("i\n");else writef("!i\n"); if(!!j)writef("j\n");else writef("!j\n"); if(!!k)writef("k\n");else writef("!k\n"); return 0; }

LOL.... try this too. writefln("%s %s", !!i, !!k); I get "true false" in return. Now this qualifies as a real D-Geek operator. -- Derek (skype: derek.j.parnell) Melbourne, Australia "Down with mediocracy!" 8/03/2006 1:15:38 PM
Mar 07 2006
next sibling parent reply Hasan Aljudy <hasan.aljudy gmail.com> writes:
Derek Parnell wrote:
 On Tue, 07 Mar 2006 18:12:41 -0800, BCS wrote:
 
 
It's not like anybody would want to write exactly

    bool x = 5;

but more like

    bool x = strcmp("foo", "bar");
    if (!x) { /* do stuff */ }        // match
    else { /* call the cops! */ }     // no match

"!!" ends up as a cast to bool try: import std.stdio; int main() { int i = 1; int j = 2; int k = 0; if(!!i)writef("i\n");else writef("!i\n"); if(!!j)writef("j\n");else writef("!j\n"); if(!!k)writef("k\n");else writef("!k\n"); return 0; }

LOL.... try this too. writefln("%s %s", !!i, !!k); I get "true false" in return. Now this qualifies as a real D-Geek operator.

ack! this is wrong!! apparently, ! returns a bool
Mar 07 2006
parent BCS <BCS_member pathlink.com> writes:
[snips]
int main()
{
	int k = 0;

	if(!!k)writef("k\n");else writef("!k\n");

LOL.... try this too. writefln("%s %s", !!i, !!k);

ack! this is wrong!! apparently, ! returns a bool

I think this (a shorthand for compare to zero) would be a vary useful thing to have officially in D, it would negate a lot of the arguments against pure bools without diluting them (much).
Mar 07 2006
prev sibling parent Wang Zhen <nehzgnaw gmail.com> writes:
Derek Parnell wrote:
 On Tue, 07 Mar 2006 18:12:41 -0800, BCS wrote:
 
 
It's not like anybody would want to write exactly

    bool x = 5;

but more like

    bool x = strcmp("foo", "bar");
    if (!x) { /* do stuff */ }        // match
    else { /* call the cops! */ }     // no match

"!!" ends up as a cast to bool try: import std.stdio; int main() { int i = 1; int j = 2; int k = 0; if(!!i)writef("i\n");else writef("!i\n"); if(!!j)writef("j\n");else writef("!j\n"); if(!!k)writef("k\n");else writef("!k\n"); return 0; }

LOL.... try this too. writefln("%s %s", !!i, !!k); I get "true false" in return. Now this qualifies as a real D-Geek operator.

This is an old C idiom.
Mar 07 2006
prev sibling parent Niko Korhonen <niktheblak hotmail.com> writes:
Georg Wrede wrote:
 A language that purports to be "to-the-metal" just has to take 
 into consideration the fundamentals of [digital] life. And processor 
 physics. (Wanna abstract away that? Then go to Java or whatever.)

You abstract away vast majority of the "fundamentals" and "processor physics" if you program in C instead of binary machine language or a specialized assembler. Actually I daresay that unless you have a PhD in physics and work at Intel or AMD you probably have already abstracted away most of processor physics, which use the word 'quantum' a lot. Let's do an example: just how closely C's standard IO facilities corresponds with implementations of actual file systems in operating systems? Not very closely at all. Indeed, they are nothing alike. C's IO system is a very high-level abstraction, even if it seems low-level because of it's design. All recent operating systems have a much more modern and "high-level" API for IO than C, even when they are of lower abstraction level, and therefore actually more low-level than C's. Do not confuse low-level with poor language design, that's what K&R and Stroustrup did. Furthermore, processor instruction sets have evolved way beyond C; do you have anything equivalent to vectorization, pareller execution or hardware threads in standard C? C may have had some resemblance to instruction sets and operating fundamentals of some specific computer architecture in the 1970's, but it hasn't had that in decades. Face it, even C is a high-level abstraction built on abstraction (which chooses to represent boolean values as integers). Every high level language is. Again, do not confuse poor design with efficiency and "low-levelism". -- Niko Korhonen SW Developer
Mar 10 2006
prev sibling next sibling parent Derek Parnell <derek psych.ward> writes:
On Tue, 7 Mar 2006 15:02:41 -0800, Walter Bright wrote:

 Changed on_scope keywords per the general consensus of the n.g.
 
 The implicit function template instantiation is a bit limited at the moment, 
 deduction won't work for types derived from templates, and the mechanism to 
 pick the most specialized template doesn't work.
 
 http://www.digitalmars.com/d/changelog.html

Bloody marvelous! ... getting better and better every day. Thanks for all the hard work and great results. I'm sorry to heap so much shit on you from time to time <G> -- Derek (skype: derek.j.parnell) Melbourne, Australia "Down with mediocracy!" 8/03/2006 10:13:42 AM
Mar 07 2006
prev sibling next sibling parent "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"Walter Bright" <newshound digitalmars.com> wrote in message 
news:dul3ku$2sv2$1 digitaldaemon.com...
 Changed on_scope keywords per the general consensus of the n.g.

 The implicit function template instantiation is a bit limited at the 
 moment, deduction won't work for types derived from templates, and the 
 mechanism to pick the most specialized template doesn't work.

 http://www.digitalmars.com/d/changelog.html

Oh, and opSliceAssign, and the if(type variable = expr) too? Just too good.
Mar 07 2006
prev sibling next sibling parent Tom S <h3r3tic remove.mat.uni.torun.pl> writes:
Walter, you re the man !


-- 
-----BEGIN GEEK CODE BLOCK-----
Version: 3.1
GCS/M d-pu s+: a-->----- C+++$>++++ UL P+ L+ E--- W++ N++ o? K? w++ !O 
!M V? PS- PE- Y PGP t 5 X? R tv-- b DI- D+ G e>+++ h>++ !r !y
------END GEEK CODE BLOCK------

Tomasz Stachowiak  /+ a.k.a. h3r3tic +/
Mar 07 2006
prev sibling next sibling parent Kyle Furlong <kylefurlong gmail.com> writes:
Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.
 
 The implicit function template instantiation is a bit limited at the moment, 
 deduction won't work for types derived from templates, and the mechanism to 
 pick the most specialized template doesn't work.
 
 http://www.digitalmars.com/d/changelog.html
 
 
 

I could kiss you. 0.150 == 1.0 ? <g>
Mar 07 2006
prev sibling next sibling parent reply Sean Kelly <sean f4.ca> writes:
Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.
 
 The implicit function template instantiation is a bit limited at the moment, 
 deduction won't work for types derived from templates, and the mechanism to 
 pick the most specialized template doesn't work.

Could you clarify this: "& | ^ &= |= ^= ! && || ?: are now only operators allowed on bools" Did you mean "are now _the_ only operators allowed on bools?" I can't imagine that bitwise operations would be disallowed on integers. As for ITI... I've already got some overloaded functions written that haven been waiting on this, so I'll let you know how it goes. Sean
Mar 07 2006
next sibling parent reply "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"Sean Kelly" <sean f4.ca> wrote in message 
news:dul5n8$2us7$1 digitaldaemon.com...
 Did you mean "are now _the_ only operators allowed on bools?"

Yes. Walter isn't _that_ big of a doof :)
Mar 07 2006
parent "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"Jarrett Billingsley" <kb3ctd2 yahoo.com> wrote in message 
news:dul5sr$2vee$1 digitaldaemon.com...
 "Sean Kelly" <sean f4.ca> wrote in message 
 news:dul5n8$2us7$1 digitaldaemon.com...
 Did you mean "are now _the_ only operators allowed on bools?"

Yes. Walter isn't _that_ big of a doof :)

Although a quick test: bool x = true; int y = x * 5; bool z = true / false; Hmm..
Mar 07 2006
prev sibling parent reply Derek Parnell <derek psych.ward> writes:
On Tue, 07 Mar 2006 15:41:28 -0800, Sean Kelly wrote:

 Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.
 
 The implicit function template instantiation is a bit limited at the moment, 
 deduction won't work for types derived from templates, and the mechanism to 
 pick the most specialized template doesn't work.

Could you clarify this: "& | ^ &= |= ^= ! && || ?: are now only operators allowed on bools" Did you mean "are now _the_ only operators allowed on bools?"

It seems that arithmetic operators also work on booleans so I guess the operator list above is either not correct or this is a bug. auto q = true + true + true; writefln("%s %s", true + true + true, q); gives "3 3" but I was expecting that the form "<expression> <arithmetic-op> <expression>" where either <expression> is a boolean result would be a syntax error. Instead, it seems to be implicitly casting the boolean to an int before the operation is examined. -- Derek (skype: derek.j.parnell) Melbourne, Australia "Down with mediocracy!" 8/03/2006 1:36:18 PM
Mar 07 2006
parent reply "Walter Bright" <newshound digitalmars.com> writes:
"Derek Parnell" <derek psych.ward> wrote in message 
news:1o1ukrzuobjw5$.19cyl0ofx7fqs$.dlg 40tude.net...
 It seems that arithmetic operators also work on booleans so I guess the
 operator list above is either not correct or this is a bug.

It's a bug. Sigh. It always takes me two tries to get this right :-(
Mar 07 2006
parent Bruno Medeiros <daiphoenixNO SPAMlycos.com> writes:
Walter Bright wrote:
 "Derek Parnell" <derek psych.ward> wrote in message 
 news:1o1ukrzuobjw5$.19cyl0ofx7fqs$.dlg 40tude.net...
 It seems that arithmetic operators also work on booleans so I guess the
 operator list above is either not correct or this is a bug.

It's a bug. Sigh. It always takes me two tries to get this right :-(

work on booleans, if you have implicit conversion from bool to int. Because bools will be threated like an int. Isn't it right? What we should have, is not have implicit conversion from bool to non-bool. Let me recall a post I made, which I don't know if you read, for more info: news://news.digitalmars.com:119/du9cnl$2h9j$3 digitaldaemon.com -- Bruno Medeiros - CS/E student http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
Mar 08 2006
prev sibling next sibling parent reply Tom S <h3r3tic remove.mat.uni.torun.pl> writes:
Walter Bright wrote:
 The implicit function template instantiation is a bit limited at the moment, 
 deduction won't work for types derived from templates, and the mechanism to 
 pick the most specialized template doesn't work.

Does the fact that implicit instantiation doesn't work when the template is a member of a class also belong to the 'limitation' category ? The error messages are quite misleading: "Foo.bar is not a declaration" and "template moduleName.Foo.bar(T) templates don't have properties" if Foo is a struct instead. -- -----BEGIN GEEK CODE BLOCK----- Version: 3.1 GCS/M d-pu s+: a-->----- C+++$>++++ UL P+ L+ E--- W++ N++ o? K? w++ !O !M V? PS- PE- Y PGP t 5 X? R tv-- b DI- D+ G e>+++ h>++ !r !y ------END GEEK CODE BLOCK------ Tomasz Stachowiak /+ a.k.a. h3r3tic +/
Mar 07 2006
next sibling parent Sean Kelly <sean f4.ca> writes:
Tom S wrote:
 Walter Bright wrote:
 The implicit function template instantiation is a bit limited at the 
 moment, deduction won't work for types derived from templates, and the 
 mechanism to pick the most specialized template doesn't work.

Does the fact that implicit instantiation doesn't work when the template is a member of a class also belong to the 'limitation' category ? The error messages are quite misleading: "Foo.bar is not a declaration" and "template moduleName.Foo.bar(T) templates don't have properties" if Foo is a struct instead.

I think the feature is just mostly unfinished--I get get very simple cases to work, but that's it. For example, in the code below, templA works just fine, but the slightly fancier templB is not accepted: C:\code\d>type test.d import std.c.stdio; template templA( Type ) { void templA( Type val ) { printf( "%.*s\n", typeid(Type).classinfo.name ); } } template templB( Type ) { void templB( Type[] val1, Type val2 ) { printf( "%.*s\n", typeid(Type).classinfo.name ); } } void main() { templA( "blah" ); templB( "blah", 'b' ); } C:\code\d>dmd test.d test.d(22): template test.templB(Type) does not match any template declaration test.d(22): template test.templB(Type) cannot deduce template function from argument types (char[4],char) C:\code\d>
Mar 07 2006
prev sibling parent "Walter Bright" <newshound digitalmars.com> writes:
"Tom S" <h3r3tic remove.mat.uni.torun.pl> wrote in message 
news:dul6ve$30gp$1 digitaldaemon.com...
 Does the fact that implicit instantiation doesn't work when the template 
 is a member of a class also belong to the 'limitation' category ?

Yes.
Mar 07 2006
prev sibling next sibling parent reply David Medlock <noone nowhere.com> writes:
Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.
 
 The implicit function template instantiation is a bit limited at the moment, 
 deduction won't work for types derived from templates, and the mechanism to 
 pick the most specialized template doesn't work.
 
 http://www.digitalmars.com/d/changelog.html
 
 

I hope you get 1.0 out before Google or IBM gets to you! The scope stuff is very, very cool. However, let me be a lone dissenter against the new if( auto = ) stuff. My issue with it is what it may do to developers taking a peek at D. C-Junkie: "Well there is my old reliable if statement...wait a minute...whats all this then? This language is too weird, I am going back to my comfortable (language-X)." This is yet another corner case bound to look small to experienced users but may shy away others from the language. Again I vote for: with( expression ) { ... } else { ... } if expression is null then the else block is executed. Of course, just my humble opinion. -DavidM
Mar 07 2006
parent reply "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"David Medlock" <noone nowhere.com> wrote in message 
news:dulc2p$7m4$1 digitaldaemon.com...
 C-Junkie: "Well there is my old reliable if statement...wait a 
 minute...whats all this then?  This language is too weird, I am going back 
 to my comfortable (language-X)."

Or they'll look at it and say, "oh, well that's cool, I've always been able to do that in for loops, now I can do it in ifs as well!" And if they give up on a language because of one new feature, they don't deserve to be using it.
Mar 07 2006
parent reply "Walter Bright" <newshound digitalmars.com> writes:
"Jarrett Billingsley" <kb3ctd2 yahoo.com> wrote in message 
news:dulcil$86q$1 digitaldaemon.com...
 And if they give up on a language because of one new feature, they don't 
 deserve to be using it.

My general experience with people who say "D is a great language, but I won't use it because of <minor nitpick> because <minor nitpick> is the most important thing in the world" is that they won't use it anyway, and are just looking for an excuse.
Mar 07 2006
next sibling parent David Medlock <noone nowhere.com> writes:
Walter Bright wrote:
 "Jarrett Billingsley" <kb3ctd2 yahoo.com> wrote in message 
 news:dulcil$86q$1 digitaldaemon.com...
 And if they give up on a language because of one new feature, they don't 
 deserve to be using it.

My general experience with people who say "D is a great language, but I won't use it because of <minor nitpick> because <minor nitpick> is the most important thing in the world" is that they won't use it anyway, and are just looking for an excuse.

I mean that its still adding corner cases to a simple construct. Corner cases make C++ the headache it is, but I am sure that each addition looked really small at the time. Ironically the declaration-in-for-statement is not really that important in D thanks to foreach. Its trivial though so I will withdraw my complaint. Cheers. -DavidM
Mar 07 2006
prev sibling parent reply MicroWizard <MicroWizard_member pathlink.com> writes:
My general experience with people who say "D is a great language, but I 
won't use it because of <minor nitpick> because <minor nitpick> is the most 
important thing in the world" is that they won't use it anyway, and are just 
looking for an excuse. 

Absolutely agree. I have told to many "friends" to check D site and tell me their opinions. Most of them had excuses: no IDE, no GUI, no ... bla-bla-bla And they use Visual Studio with Intellisense and such crap. (I use DMD as regular compiler for small inhouse projects for two years. And I really like it.) D is not for every "code writer", it is for developers. Tamas Nagy
Mar 09 2006
parent reply Charles Hixson <charleshixsn earthlink.net> writes:
MicroWizard wrote:

My general experience with people who say "D is a great language, but I
won't use it because of <minor nitpick> because <minor nitpick> is the
most important thing in the world" is that they won't use it anyway, and
are just looking for an excuse.

Absolutely agree. I have told to many "friends" to check D site and tell me their opinions. Most of them had excuses: no IDE, no GUI, no ... bla-bla-bla And they use Visual Studio with Intellisense and such crap. (I use DMD as regular compiler for small inhouse projects for two years. And I really like it.) D is not for every "code writer", it is for developers. Tamas Nagy

what your project is. I currently have two projects in mind. For one of them I may choose D, for the other...no stable GUI is a project killer. N.B.: This is not unique to D. Every new language comes to this problem, which may be condensed into a simple word: LIBRARIES!!! This is why a GOOD connection to C is so important to D. (And it's why an automated build tool that can add C code and D code together is important.) In the early days I remember a comment where Walter was looking at adding an automatic conversion of C header files into D files ... and decided that it was too difficult a job to do in a general way. (He also pointed at his C or C++ [I forget which] compiler, and showed how to use it as a preprocessor...which didn't help me as I'm using Linux, but demonstrated that he DID understand the problem.) Actually, a version of this is why I've chosen Python over Ruby for some projects. I think that Ruby is a much better language, but Python started earlier, so Python has the libraries. This is a serious problem, and I don't know any way to solve it. It can "sort of" be handled by just continuing on, and developing libraries in passing. Over time the most critical libraries will be added. But note that Ruby is STILL severely behind Python. This is not a problem that can be handled quickly in this way. A solution would dissolve the problem by allowing transparent access to, e.g., C libraries. (Even this wouldn't be a total solution, because then there will be the problem of documentation...where the documentation for the libraries will all be directed at users of the original language.) This is probably a problem that we must be satisfied with handling rather than solving. Over time it will decrease in importance. Currently, while the GUI and database libraries are missing/primitive/fragile ... well, a lot of the time D won't be the correct language, even though as a language it would be the correct choice. -- Work in progress
Mar 12 2006
next sibling parent MicroWizard <MicroWizard_member pathlink.com> writes:
Sorry, but I feel you missed the point.

No language was born _with_ libraries. Not M$ ones.
Who want to use D imediately he/she is a coder, not a developer,
who tries to use the possibilities.

In my professional life I have to work with M$ things. That place I am a coder
only. I satisfy customer's needs. I use RAD. I earn money. I often hate it.

In this community I can see the possibility to participate in some good new
things to create. It needs time to grow. No reason to hurry.

Tamas Nagy

In article <dv243r$1qa$1 digitaldaemon.com>, Charles Hixson says...
MicroWizard wrote:

My general experience with people who say "D is a great language, but I
won't use it because of <minor nitpick> because <minor nitpick> is the
most important thing in the world" is that they won't use it anyway, and
are just looking for an excuse.

Absolutely agree. I have told to many "friends" to check D site and tell me their opinions. Most of them had excuses: no IDE, no GUI, no ... bla-bla-bla And they use Visual Studio with Intellisense and such crap. (I use DMD as regular compiler for small inhouse projects for two years. And I really like it.) D is not for every "code writer", it is for developers. Tamas Nagy

what your project is. I currently have two projects in mind. For one of them I may choose D, for the other...no stable GUI is a project killer. N.B.: This is not unique to D. Every new language comes to this problem, which may be condensed into a simple word: LIBRARIES!!! This is why a GOOD connection to C is so important to D. (And it's why an automated build tool that can add C code and D code together is important.) In the early days I remember a comment where Walter was looking at adding an automatic conversion of C header files into D files ... and decided that it was too difficult a job to do in a general way. (He also pointed at his C or C++ [I forget which] compiler, and showed how to use it as a preprocessor...which didn't help me as I'm using Linux, but demonstrated that he DID understand the problem.) Actually, a version of this is why I've chosen Python over Ruby for some projects. I think that Ruby is a much better language, but Python started earlier, so Python has the libraries. This is a serious problem, and I don't know any way to solve it. It can "sort of" be handled by just continuing on, and developing libraries in passing. Over time the most critical libraries will be added. But note that Ruby is STILL severely behind Python. This is not a problem that can be handled quickly in this way. A solution would dissolve the problem by allowing transparent access to, e.g., C libraries. (Even this wouldn't be a total solution, because then there will be the problem of documentation...where the documentation for the libraries will all be directed at users of the original language.) This is probably a problem that we must be satisfied with handling rather than solving. Over time it will decrease in importance. Currently, while the GUI and database libraries are missing/primitive/fragile ... well, a lot of the time D won't be the correct language, even though as a language it would be the correct choice. -- Work in progress

Mar 12 2006
prev sibling parent reply Don Clugston <dac nospam.com.au> writes:
Charles Hixson wrote:
 MicroWizard wrote:
 
 My general experience with people who say "D is a great language, but I
 won't use it because of <minor nitpick> because <minor nitpick> is the
 most important thing in the world" is that they won't use it anyway, and
 are just looking for an excuse.

I have told to many "friends" to check D site and tell me their opinions. Most of them had excuses: no IDE, no GUI, no ... bla-bla-bla And they use Visual Studio with Intellisense and such crap. (I use DMD as regular compiler for small inhouse projects for two years. And I really like it.) D is not for every "code writer", it is for developers. Tamas Nagy

what your project is. I currently have two projects in mind. For one of them I may choose D, for the other...no stable GUI is a project killer. N.B.: This is not unique to D. Every new language comes to this problem, which may be condensed into a simple word: LIBRARIES!!! This is why a GOOD connection to C is so important to D. (And it's why an automated build tool that can add C code and D code together is important.) In the early days I remember a comment where Walter was looking at adding an automatic conversion of C header files into D files ... and decided that it was too difficult a job to do in a general way. (He also pointed at his C or C++ [I forget which] compiler, and showed how to use it as a preprocessor...which didn't help me as I'm using Linux, but demonstrated that he DID understand the problem.) Actually, a version of this is why I've chosen Python over Ruby for some projects. I think that Ruby is a much better language, but Python started earlier, so Python has the libraries. This is a serious problem, and I don't know any way to solve it. It can "sort of" be handled by just continuing on, and developing libraries in passing. Over time the most critical libraries will be added. But note that Ruby is STILL severely behind Python. This is not a problem that can be handled quickly in this way. A solution would dissolve the problem by allowing transparent access to, e.g., C libraries. (Even this wouldn't be a total solution, because then there will be the problem of documentation...where the documentation for the libraries will all be directed at users of the original language.) This is probably a problem that we must be satisfied with handling rather than solving. Over time it will decrease in importance. Currently, while the GUI and database libraries are missing/primitive/fragile ... well, a lot of the time D won't be the correct language, even though as a language it would be the correct choice.

I completely agree with this. I think the language is good enough now that future progress will be limited by the quality of the libraries. The most severe symptom is that right now, D doesn't even have proper windows headers! IMHO, it's not currently suitable for anything that involves I/O other than reading and writing files. The 'implib' tool has done a lot to improve the situation with respect to C libraries -- now at least we can link to them. We just need a header file converter. I've been trying to understand the 'problem space' for C -> D header conversion. It seems to me, that it is a solvable problem, once you accept that because of ambiguities in the C preprocessor, a fully automatic conversion is impossible. My proposed solution is to have a prepreprocessor, which modifies a C header into a format without ambiguities, which can then be converted automatically. I think that if we had such a tool, D would be vastly more usable. I think this issue is about to become 'mission critical' for D.
Mar 13 2006
parent reply =?ISO-8859-1?Q?Anders_F_Bj=F6rklund?= <afb algonet.se> writes:
Don Clugston wrote:

 The most severe symptom is that right now, D doesn't even have proper 
 windows headers!

But if you're not programming for Windows, that is not a problem... :-) --anders
Mar 13 2006
parent reply Don Clugston <dac nospam.com.au> writes:
Anders F Björklund wrote:
 Don Clugston wrote:
 
 The most severe symptom is that right now, D doesn't even have proper 
 windows headers!

But if you're not programming for Windows, that is not a problem... :-)

True -- that's why I called it a symptom. The situation is no better for Linux, and seems like the Mac guys don't even have a compiler...
 
 --anders

Mar 13 2006
parent reply =?ISO-8859-1?Q?Anders_F_Bj=F6rklund?= <afb algonet.se> writes:
Don Clugston wrote:

 The most severe symptom is that right now, D doesn't even have proper 
 windows headers!

But if you're not programming for Windows, that is not a problem... :-)

True -- that's why I called it a symptom. The situation is no better for Linux, and seems like the Mac guys don't even have a compiler...

But is that a language problem ? Other than that D deliberately chose to not be read-compatible with C headers, or linkable with C++ libraries ? We all agree that a C-header-to-D-import module tool would be useful, I think Walter even noted that on the DMD compiler page from the start. But when I've translated the headers, the rest seems to be working... Except for templates of course, but that's "just a Mac problem" eh ? Just think that there are bigger bugs with Phobos than just missing some Windows headers or having incomplete headers for the C stdlib... I have a library here that I can compare implementations for, and out of C++ and Objective-C and now D - the D version is the neatest one by far! --anders
Mar 13 2006
parent reply Don Clugston <dac nospam.com.au> writes:
Anders F Björklund wrote:
 Don Clugston wrote:
 
 The most severe symptom is that right now, D doesn't even have 
 proper windows headers!

But if you're not programming for Windows, that is not a problem... :-)

True -- that's why I called it a symptom. The situation is no better for Linux, and seems like the Mac guys don't even have a compiler...

But is that a language problem ? Other than that D deliberately chose to not be read-compatible with C headers, or linkable with C++ libraries ?

No, but it is a practical problem, which makes it hard to justify the use of D.
 We all agree that a C-header-to-D-import module tool would be useful,
 I think Walter even noted that on the DMD compiler page from the start.
 
 But when I've translated the headers, the rest seems to be working...
 Except for templates of course, but that's "just a Mac problem" eh ?
 
 Just think that there are bigger bugs with Phobos than just missing
 some Windows headers or having incomplete headers for the C stdlib...

I didn't intend to imply that there were no other symptoms... <g>
 I have a library here that I can compare implementations for, and out of 
 C++ and Objective-C and now D - the D version is the neatest one by far!

You're preaching to the converted <g>. Right now we have a world-beating language, that's totally embarrassed about the state of its libraries (the IDE is a minor issue in comparison). It's a genuine, serious problem. It might not be too hard to fix, but that doesn't stop it from being a blocker right now.
Mar 13 2006
parent =?ISO-8859-1?Q?Anders_F_Bj=F6rklund?= <afb algonet.se> writes:
Don Clugston wrote:

 I have a library here that I can compare implementations for, and out 
 of C++ and Objective-C and now D - the D version is the neatest one by 
 far!

You're preaching to the converted <g>.

What I meant was that even without a good std library, it's still ahead. (The C++ version was using Carbon, and the Objective-C was using Cocoa) I guess that's a side-effect of the "don't do in a standard library what can be done in the compiler", which seems to be a part of D philosophy ?
 Right now we have a world-beating language, that's totally embarrassed 
 about the state of its libraries (the IDE is a minor issue in 
 comparison). It's a genuine, serious problem. It might not be too hard 
 to fix, but that doesn't stop it from being a blocker right now.

I wrapped my own "showstopper" libraries, so those weren't really it... I've found that people invent other reasons, to not have to look at D ? The good part is that "C" libraries can be used by all three languages. (the bad of course being that I then need to code the whole thing in C) --anders
Mar 13 2006
prev sibling next sibling parent John Reimer <terminal.node gmail.com> writes:
Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.
 
 The implicit function template instantiation is a bit limited at the moment, 
 deduction won't work for types derived from templates, and the mechanism to 
 pick the most specialized template doesn't work.
 
 http://www.digitalmars.com/d/changelog.html
 
 
 

Excellent fix to the scope statement. Thank you again, Walter. I like where this is headed. Keep up the good work. D is looking more attractive and exciting all the time. -JJR
Mar 07 2006
prev sibling next sibling parent reply Lucas Goss <lgoss007 gmail.com> writes:
Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.

nooooooooooooooooooooooooo... I guess I was the only one that didn't like the proposed change of scope(...). Inconsistencies in d drive me mad (crazy). I love the language and hate it at the same time. The other changes are nice though, nice work.
Mar 07 2006
next sibling parent "Walter Bright" <newshound digitalmars.com> writes:
"Lucas Goss" <lgoss007 gmail.com> wrote in message 
news:dulcq5$8cj$1 digitaldaemon.com...
 Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.

nooooooooooooooooooooooooo... I guess I was the only one that didn't like the proposed change of scope(...). Inconsistencies in d drive me mad (crazy). I love the language and hate it at the same time.

LOL. I can't please everybody <g>.
Mar 07 2006
prev sibling next sibling parent Sean Kelly <sean f4.ca> writes:
Lucas Goss wrote:
 Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.

nooooooooooooooooooooooooo... I guess I was the only one that didn't like the proposed change of scope(...). Inconsistencies in d drive me mad (crazy).

I liked the old form as well. Ah well :-) Sean
Mar 07 2006
prev sibling next sibling parent reply Hasan Aljudy <hasan.aljudy gmail.com> writes:
Lucas Goss wrote:
 Walter Bright wrote:
 
 Changed on_scope keywords per the general consensus of the n.g.

nooooooooooooooooooooooooo... I guess I was the only one that didn't like the proposed change of scope(...). Inconsistencies in d drive me mad (crazy). I love the language and hate it at the same time. The other changes are nice though, nice work.

What's the inconsistency here?
Mar 07 2006
parent reply Lucas Goss <lgoss007 gmail.com> writes:
Hasan Aljudy wrote:
 Lucas Goss wrote:
 Walter Bright wrote:

 Changed on_scope keywords per the general consensus of the n.g.

nooooooooooooooooooooooooo... I guess I was the only one that didn't like the proposed change of scope(...). Inconsistencies in d drive me mad (crazy). I love the language and hate it at the same time.

What's the inconsistency here?

The inconsistency is in the style of the language. Where else in the language is there a keyword inside another keyword? Yes I know exit, success, and failure aren't necessarily keywords, but they are within the context of scope() (or scope of scope, :) ). The only other instance I can think of is switch(), but "case" is in the block of the switch statement (not inside the parenthesis). All other keywords with ()'s have expressions/conditions inside. It kinda reminds me of the English language (my native tongue by the way), where some things just stick out like a sore thumb... Bologna - pronounced Bolony? Well I guess it allows us to add stuff later, as in: scope(creep) hahaha... sorry I couldn't resist :)
Mar 08 2006
next sibling parent reply Hasan Aljudy <hasan.aljudy gmail.com> writes:
Lucas Goss wrote:
 Hasan Aljudy wrote:
 
 Lucas Goss wrote:

 Walter Bright wrote:

 Changed on_scope keywords per the general consensus of the n.g.

nooooooooooooooooooooooooo... I guess I was the only one that didn't like the proposed change of scope(...). Inconsistencies in d drive me mad (crazy). I love the language and hate it at the same time.

What's the inconsistency here?

The inconsistency is in the style of the language. Where else in the language is there a keyword inside another keyword?

while(true) :)
 Yes I know exit, 
 success, and failure aren't necessarily keywords, but they are within 
 the context of scope() (or scope of scope, :) ). The only other instance 
 I can think of is switch(), but "case" is in the block of the switch 
 statement (not inside the parenthesis). All other keywords with ()'s 
 have expressions/conditions inside.
 

D inherits alot of inconsistencies from C .. for loops vs while loops.. horrible inconsistency!! You actually but semi-colon seperated statements inside the for( .. ) switch/case/break construct doesn't really resemble anything!! key_words_with_under_scores_are_worse
Mar 08 2006
parent reply Lucas Goss <lgoss007 gmail.com> writes:
Hasan Aljudy wrote:
 Lucas Goss wrote:
 The inconsistency is in the style of the language. Where else in the 
 language is there a keyword inside another keyword?

while(true) :)

Hmm, true. But while accepts a condition. So I can do: while(myTimer < 1000), while(!done) but I can't do: scope(isFinished), scope(timerAbort)
 D inherits alot of inconsistencies from C ..

Yeah that's what kills me. I can use a nice consistent language like C# or Java, or a nice performing language like C/C++ or D. Why can't I have both... sigh.
 for loops vs while loops.. horrible inconsistency!! You actually but 
 semi-colon seperated statements inside the for( .. )

I don't like those either.
 switch/case/break construct doesn't really resemble anything!!

Yeah, basically a bunch of if/else if/else statements in disguise.
 key_words_with_under_scores_are_worse

Yeah I don't like the key_words_with_underscores either, that's why I wanted a change, just not the kind with ()'s.
Mar 08 2006
parent Bruno Medeiros <daiphoenixNO SPAMlycos.com> writes:
Lucas Goss wrote:
 Hasan Aljudy wrote:
 Lucas Goss wrote:
 The inconsistency is in the style of the language. Where else in the 
 language is there a keyword inside another keyword?

while(true) :)

Hmm, true. But while accepts a condition. So I can do: while(myTimer < 1000), while(!done) but I can't do: scope(isFinished), scope(timerAbort)

really doesn't serve as an example. -- Bruno Medeiros - CS/E student http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
Mar 09 2006
prev sibling parent reply "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"Lucas Goss" <lgoss007 gmail.com> wrote in message 
news:dun5ej$2vej$1 digitaldaemon.com...
 The inconsistency is in the style of the language. Where else in the 
 language is there a keyword inside another keyword? Yes I know exit, 
 success, and failure aren't necessarily keywords, but they are within the 
 context of scope() (or scope of scope, :) ).

extern(C) pragma(msg, "hi")
Mar 08 2006
parent reply Lucas Goss <lgoss007 gmail.com> writes:
Jarrett Billingsley wrote:
 "Lucas Goss" <lgoss007 gmail.com> wrote in message 
 news:dun5ej$2vej$1 digitaldaemon.com...
 The inconsistency is in the style of the language. Where else in the 
 language is there a keyword inside another keyword? Yes I know exit, 
 success, and failure aren't necessarily keywords, but they are within the 
 context of scope() (or scope of scope, :) ).

extern(C) pragma(msg, "hi")

I knew there was some I wasn't thinking of. And version(name) too. Thinking about it, does that mean this can be done?: scope(exit) { class1.cleanup(); class2.cleanup(); } I think of it more like an event accumulator stack, not really a statement, so this just seems strange: scope(exit) class1.cleanup(); scope(exit) class2.cleanup(); Maybe because I don't do anything like: if(thisIsTrue) okToExecute();
Mar 08 2006
parent "Derek Parnell" <derek psych.ward> writes:
On Thu, 09 Mar 2006 07:53:20 +1100, Lucas Goss <lgoss007 gmail.com> wrote:


 Thinking about it, does that mean this can be done?:
 scope(exit) {
     class1.cleanup();
     class2.cleanup();
 }

Yes.
 I think of it more like an event accumulator stack, not really a  
 statement, so this just seems strange:
 scope(exit) class1.cleanup();
 scope(exit) class2.cleanup();

However, the two are different in that the first example above the order of execution is class1.cleanup then class2.cleanup, but it is reversed in example #2 as they get run in reverse lexical order. -- Derek Parnell Melbourne, Australia
Mar 08 2006
prev sibling next sibling parent reply AgentOrange <AgentOrange_member pathlink.com> writes:
In article <dulcq5$8cj$1 digitaldaemon.com>, Lucas Goss says...
Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.

nooooooooooooooooooooooooo... I guess I was the only one that didn't like the proposed change of scope(...). Inconsistencies in d drive me mad (crazy). I love the language and hate it at the same time. The other changes are nice though, nice work.

this especially bites for those of us using scope as an identifier... :(
Mar 07 2006
parent reply Derek Parnell <derek psych.ward> writes:
On Wed, 8 Mar 2006 05:25:29 +0000 (UTC), AgentOrange wrote:

 In article <dulcq5$8cj$1 digitaldaemon.com>, Lucas Goss says...
Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.

nooooooooooooooooooooooooo... I guess I was the only one that didn't like the proposed change of scope(...). Inconsistencies in d drive me mad (crazy). I love the language and hate it at the same time. The other changes are nice though, nice work.

this especially bites for those of us using scope as an identifier... :(

This is kinda off topic but I can't understand why coders still use standard words for identifiers. I mean after all these years of experience with computing languages, this is one common source of bugs and problems. So to make coding life easier, just stop using single normal words for identifiers. Pick a naming convention that prevents this habit and the chances you are going to clash with reserved words is greatly reduced. It not really all that hard. -- Derek (skype: derek.j.parnell) Melbourne, Australia "Down with mediocracy!" 8/03/2006 4:36:11 PM
Mar 07 2006
next sibling parent AgentOrange <AgentOrange_member pathlink.com> writes:
In article <1osp8dzdh9ihy$.yoi1lhqbyw8f$.dlg 40tude.net>, Derek Parnell says...
On Wed, 8 Mar 2006 05:25:29 +0000 (UTC), AgentOrange wrote:

 In article <dulcq5$8cj$1 digitaldaemon.com>, Lucas Goss says...
Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.

nooooooooooooooooooooooooo... I guess I was the only one that didn't like the proposed change of scope(...). Inconsistencies in d drive me mad (crazy). I love the language and hate it at the same time. The other changes are nice though, nice work.

this especially bites for those of us using scope as an identifier... :(

This is kinda off topic but I can't understand why coders still use standard words for identifiers. I mean after all these years of experience with computing languages, this is one common source of bugs and problems. So to make coding life easier, just stop using single normal words for identifiers. Pick a naming convention that prevents this habit and the chances you are going to clash with reserved words is greatly reduced. It not really all that hard. -- Derek (skype: derek.j.parnell) Melbourne, Australia "Down with mediocracy!" 8/03/2006 4:36:11 PM

#1 I completely agree with you #2 Please look at the DMD front end written by Walter Bright ;)
Mar 07 2006
prev sibling next sibling parent reply Wang Zhen <nehzgnaw gmail.com> writes:
Derek Parnell wrote:
 On Wed, 8 Mar 2006 05:25:29 +0000 (UTC), AgentOrange wrote:
 
 
In article <dulcq5$8cj$1 digitaldaemon.com>, Lucas Goss says...

Walter Bright wrote:

Changed on_scope keywords per the general consensus of the n.g.

nooooooooooooooooooooooooo... I guess I was the only one that didn't like the proposed change of scope(...). Inconsistencies in d drive me mad (crazy). I love the language and hate it at the same time. The other changes are nice though, nice work.

this especially bites for those of us using scope as an identifier... :(

This is kinda off topic but I can't understand why coders still use standard words for identifiers. I mean after all these years of experience with computing languages, this is one common source of bugs and problems. So to make coding life easier, just stop using single normal words for identifiers. Pick a naming convention that prevents this habit and the chances you are going to clash with reserved words is greatly reduced. It not really all that hard.

Avoid English words. Problem solved.
Mar 07 2006
parent MicroWizard <MicroWizard_member pathlink.com> writes:
Avoid English words. Problem solved.

I am hungarian and use this technique for years ;-) But seriously ... Own programs could be written in our mother tongue, commonly used codes couldn't. Tamas Nagy
Mar 09 2006
prev sibling parent reply Mark T <Mark_member pathlink.com> writes:
In article <1osp8dzdh9ihy$.yoi1lhqbyw8f$.dlg 40tude.net>, Derek Parnell says...
This is kinda off topic but I can't understand why coders still use
standard words for identifiers. I mean after all these years of experience
with computing languages, this is one common source of bugs and problems. 

So to make coding life easier, just stop using single normal words for
identifiers. Pick a naming convention that prevents this habit and the
chances you are going to clash with reserved words is greatly reduced. It
not really all that hard.

I hope you don't mean "Hungarian" notation or other cryptic naming hacks. I find that code style impossible to read.
Mar 11 2006
parent reply Thomas Kuehne <thomas-dloop kuehne.cn> writes:
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Mark T schrieb am 2006-03-11:
 In article <1osp8dzdh9ihy$.yoi1lhqbyw8f$.dlg 40tude.net>, Derek Parnell says...
This is kinda off topic but I can't understand why coders still use
standard words for identifiers. I mean after all these years of experience
with computing languages, this is one common source of bugs and problems. 

So to make coding life easier, just stop using single normal words for
identifiers. Pick a naming convention that prevents this habit and the
chances you are going to clash with reserved words is greatly reduced. It
not really all that hard.

I hope you don't mean "Hungarian" notation or other cryptic naming hacks. I find that code style impossible to read.

I just love C#:
 class NamingOnTheRocks{
    static int  if(int  while){
        return  while *  while;
    }

    public static int Main(string[] args){
        int  return;
        int  static = 3,  switch = 8,  break = 2,  case = 3,  true = 0;

        if( if( switch +  break) *  case !=  true){
             return =  static;
        }else{
             return =  break /  static;
        }

        return  return * 2;
    }
 }

No joke - this is valid C# ! Thomas -----BEGIN PGP SIGNATURE----- iD8DBQFEExwM3w+/yD4P9tIRAkYcAJ4t0J7N8GBtEmqudyhqfPGtkKTTcQCeJ6KQ HOQe1kloEuePxzT+D4SvKpc= =S/gt -----END PGP SIGNATURE-----
Mar 11 2006
parent reply Sean Kelly <sean f4.ca> writes:
Thomas Kuehne wrote:
 
 I just love C#:
 
 class NamingOnTheRocks{
    static int  if(int  while){
        return  while *  while;
    }

    public static int Main(string[] args){
        int  return;
        int  static = 3,  switch = 8,  break = 2,  case = 3,  true = 0;

        if( if( switch +  break) *  case !=  true){
             return =  static;
        }else{
             return =  break /  static;
        }

        return  return * 2;
    }
 }

No joke - this is valid C# !

What a wonderful language :-p What does the ' ' represent? Sean
Mar 11 2006
parent Thomas Kuehne <thomas-dloop kuehne.cn> writes:
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Sean Kelly schrieb am 2006-03-11:
 Thomas Kuehne wrote:
 
 I just love C#:
 
 class NamingOnTheRocks{
    static int  if(int  while){
        return  while *  while;
    }

    public static int Main(string[] args){
        int  return;
        int  static = 3,  switch = 8,  break = 2,  case = 3,  true = 0;

        if( if( switch +  break) *  case !=  true){
             return =  static;
        }else{
             return =  break /  static;
        }

        return  return * 2;
    }
 }

No joke - this is valid C# !

What a wonderful language :-p What does the ' ' represent?

indicates an identifier following: "int x;" and "int x;" are identical. As a consequence you can write "int some_keyword;" while you can't write "int some_keyword;". Thomas -----BEGIN PGP SIGNATURE----- iD8DBQFEFBQL3w+/yD4P9tIRAiMGAJ9smOA/+OyRyvG8DjcEHuANzONPlwCfbt7s efcS8sgqUuY1RAEtFMqIFdw= =eSt9 -----END PGP SIGNATURE-----
Mar 12 2006
prev sibling next sibling parent Chris Sauls <ibisbasenji gmail.com> writes:
Lucas Goss wrote:
 Walter Bright wrote:
 
 Changed on_scope keywords per the general consensus of the n.g.

nooooooooooooooooooooooooo... I guess I was the only one that didn't like the proposed change of scope(...). Inconsistencies in d drive me mad (crazy). I love the language and hate it at the same time. The other changes are nice though, nice work.

No no, I preferred the original myself. I also really liked the if(;) syntax, but alas. Although... I didn't see anything in the ChangeLog saying the if(;) syntax is /gone/, just that the if(auto=) syntax was added. Hmm. Must check that. Meanwhile, I have to deal with these scope(*) statements, with yet more language defined constants (exit/success/failure) for IDEs and highlighters to trip over. Fantastic. -- Chris Nicholson-Sauls
Mar 08 2006
prev sibling parent Bruno Medeiros <daiphoenixNO SPAMlycos.com> writes:
Lucas Goss wrote:
 Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.

nooooooooooooooooooooooooo... I guess I was the only one that didn't like the proposed change of scope(...). Inconsistencies in d drive me mad (crazy). I love the language and hate it at the same time. The other changes are nice though, nice work.

I miss the 'on' in this new syntax. But anyway, I can't find any syntax that I do like. -- Bruno Medeiros - CS/E student http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
Mar 09 2006
prev sibling next sibling parent Wang Zhen <nehzgnaw gmail.com> writes:
Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.
 
 The implicit function template instantiation is a bit limited at the moment, 
 deduction won't work for types derived from templates, and the mechanism to 
 pick the most specialized template doesn't work.
 
 http://www.digitalmars.com/d/changelog.html
 
 
 

Great work, Walter! I'll throw out more bizarre test cases to help you perfect dmd ;)
Mar 07 2006
prev sibling next sibling parent reply BCS <BCS_member pathlink.com> writes:
Quote from change log:
	Added std.c.fenv.

Where's the documentation? Then again where's the documentation for most of
std.c.*?
Mar 07 2006
next sibling parent reply Derek Parnell <derek psych.ward> writes:
On Tue, 07 Mar 2006 18:04:08 -0800, BCS wrote:

 Quote from change log:
 	Added std.c.fenv.
 
 Where's the documentation? Then again where's the documentation for most of
std.c.*?

I comes with your C compiler <G> -- Derek (skype: derek.j.parnell) Melbourne, Australia "Down with mediocracy!" 8/03/2006 1:12:42 PM
Mar 07 2006
next sibling parent BCS <BCS_member pathlink.com> writes:
Derek Parnell wrote:
 On Tue, 07 Mar 2006 18:04:08 -0800, BCS wrote:
 
 
Quote from change log:
	Added std.c.fenv.

Where's the documentation? Then again where's the documentation for most of
std.c.*?

I comes with your C compiler <G>

C compiler? Now where did I put that thing? :P
Mar 07 2006
prev sibling parent reply jicman <jicman_member pathlink.com> writes:
Derek Parnell says...
On Tue, 07 Mar 2006 18:04:08 -0800, BCS wrote:

 Quote from change log:
 	Added std.c.fenv.
 
 Where's the documentation? Then again where's the documentation for most of
std.c.*?

I comes with your C compiler <G>

Huh! I just downloaded the dmc compiler and there is nothing there about fenv. Where can I find it? It's not in c:\dm. Where is it?
Mar 13 2006
parent reply "Regan Heath" <regan netwin.co.nz> writes:
On Tue, 14 Mar 2006 01:07:43 +0000 (UTC), jicman  
<jicman_member pathlink.com> wrote:

 Derek Parnell says...
 On Tue, 07 Mar 2006 18:04:08 -0800, BCS wrote:

 Quote from change log:
 	Added std.c.fenv.

 Where's the documentation? Then again where's the documentation for  
 most of std.c.*?

I comes with your C compiler <G>

Huh! I just downloaded the dmc compiler and there is nothing there about fenv. Where can I find it? It's not in c:\dm. Where is it?

Try: http://www.digitalmars.com/rtl/fenv.html I opened std.c.fenv.d, I grabbed a function name, I google for "site:digitalmars.com <function>" and I got back that page as a result :) Regan
Mar 13 2006
parent jicman <jicman_member pathlink.com> writes:
Thanks. :-)

Regan Heath says...
On Tue, 14 Mar 2006 01:07:43 +0000 (UTC), jicman  
<jicman_member pathlink.com> wrote:

 Derek Parnell says...
 On Tue, 07 Mar 2006 18:04:08 -0800, BCS wrote:

 Quote from change log:
 	Added std.c.fenv.

 Where's the documentation? Then again where's the documentation for  
 most of std.c.*?

I comes with your C compiler <G>

Huh! I just downloaded the dmc compiler and there is nothing there about fenv. Where can I find it? It's not in c:\dm. Where is it?

Try: http://www.digitalmars.com/rtl/fenv.html I opened std.c.fenv.d, I grabbed a function name, I google for "site:digitalmars.com <function>" and I got back that page as a result :) Regan

Mar 13 2006
prev sibling parent reply "Walter Bright" <newshound digitalmars.com> writes:
"BCS" <BCS_member pathlink.com> wrote in message 
news:dule2p$5tn$1 digitaldaemon.com...
 Quote from change log:
 Added std.c.fenv.

 Where's the documentation? Then again where's the documentation for most 
 of std.c.*?

I haven't bothered because it will be, by definition, identical to standard C documentation for those declarations.
Mar 07 2006
parent BCS <BCS_member pathlink.com> writes:
In article <duli9p$fl0$4 digitaldaemon.com>, Walter Bright says...
"BCS" <BCS_member pathlink.com> wrote in message 
news:dule2p$5tn$1 digitaldaemon.com...
 Quote from change log:
 Added std.c.fenv.

 Where's the documentation? Then again where's the documentation for most 
 of std.c.*?

I haven't bothered because it will be, by definition, identical to standard C documentation for those declarations.

Just a list of the function in the docs would be nice, one line of description would be terrific.
Mar 07 2006
prev sibling next sibling parent Brad Roberts <braddr puremagic.com> writes:
On Tue, 7 Mar 2006, Walter Bright wrote:

 Changed on_scope keywords per the general consensus of the n.g.
 
 The implicit function template instantiation is a bit limited at the moment, 
 deduction won't work for types derived from templates, and the mechanism to 
 pick the most specialized template doesn't work.
 
 http://www.digitalmars.com/d/changelog.html

For those that don't routinely read digitalmars.D.bugs, please use http://d.puremagic.com/bugzilla/ to report issues. All new bugs and bug correspondence is forwarded to .bugs automatically. See .bugs for more discussion on the tracking system. Later, Brad
Mar 07 2006
prev sibling next sibling parent Don Clugston <dac nospam.com.au> writes:
Walter Bright wrote:
 The implicit function template instantiation is a bit limited at the moment, 
 deduction won't work for types derived from templates, and the mechanism to 
 pick the most specialized template doesn't work.

Frightening! This was IMHO the #1 advantage C++ still had over D. It might be enough to swing some of the boost crowd over here. It seems that by the time you do your presentation, C++ templates will look positively archaic. <g> BTW, when you update the comparison chart, you might want to split "Value Template Parameters" into Integral (which C++ has) and floating point/string (which it doesn't).
Mar 08 2006
prev sibling next sibling parent Ivan Senji <ivan.senji_REMOVE_ _THIS__gmail.com> writes:
Walter Bright wrote:
 Changed on_scope keywords per the general consensus of the n.g.
 
 The implicit function template instantiation is a bit limited at the moment, 
 deduction won't work for types derived from templates, and the mechanism to 
 pick the most specialized template doesn't work.
 
 http://www.digitalmars.com/d/changelog.html
 

Wow, great work Walter :)
Mar 08 2006
prev sibling parent reply Kevin Bealer <Kevin_member pathlink.com> writes:
In article <dul3ku$2sv2$1 digitaldaemon.com>, Walter Bright says...
Changed on_scope keywords per the general consensus of the n.g.

The implicit function template instantiation is a bit limited at the moment, 
deduction won't work for types derived from templates, and the mechanism to 
pick the most specialized template doesn't work.

http://www.digitalmars.com/d/changelog.html

Excellent! Just to clarify though... Are exit, success, and failure forbidden as idents or otherwise keyword-like outside of the "scope(X)" construct? Kevin
Mar 08 2006
parent "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"Kevin Bealer" <Kevin_member pathlink.com> wrote in message 
news:duo3sf$1j7h$1 digitaldaemon.com...
 Are exit, success, and failure forbidden as idents or otherwise 
 keyword-like
 outside of the "scope(X)" construct?

Nah. You can use them as much as you like. int exit = 5;
Mar 08 2006